167 files changed, 339770 insertions, 0 deletions

diff --git a/src/doc/rustc-dev-guide/src/SUMMARY.md b/src/doc/rustc-dev-guide/src/SUMMARY.md
new file mode 100644
index 000000000..99b24fe59
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/SUMMARY.md
@@ -0,0 +1,181 @@
+# Summary
+
+[About this guide](./about-this-guide.md)
+
+[Getting Started](./getting-started.md)
+
+---
+
+# Building and debugging `rustc`
+
+- [How to Build and Run the Compiler](./building/how-to-build-and-run.md)
+    - [Prerequisites](./building/prerequisites.md)
+    - [Suggested Workflows](./building/suggested.md)
+    - [Distribution artifacts](./building/build-install-distribution-artifacts.md)
+    - [Building Documentation](./building/compiler-documenting.md)
+    - [Rustdoc overview](./rustdoc.md)
+    - [Adding a new target](./building/new-target.md)
+- [Testing the compiler](./tests/intro.md)
+    - [Running tests](./tests/running.md)
+        - [Testing with Docker](./tests/docker.md)
+        - [Testing with CI](./tests/ci.md)
+    - [Adding new tests](./tests/adding.md)
+    - [Compiletest](./tests/compiletest.md)
+        - [UI tests](./tests/ui.md)
+        - [Test headers](./tests/headers.md)
+    - [Performance testing](./tests/perf.md)
+    - [Crater](./tests/crater.md)
+- [Debugging the Compiler](./compiler-debugging.md)
+    - [Using the tracing/logging instrumentation](./tracing.md)
+- [Profiling the compiler](./profiling.md)
+    - [with the linux perf tool](./profiling/with_perf.md)
+    - [with Windows Performance Analyzer](./profiling/wpa_profiling.md)
+- [crates.io Dependencies](./crates-io.md)
+
+
+# Contributing to Rust
+
+- [Introduction](./contributing.md)
+- [About the compiler team](./compiler-team.md)
+- [Using Git](./git.md)
+- [Mastering @rustbot](./rustbot.md)
+- [Walkthrough: a typical contribution](./walkthrough.md)
+- [Bug Fix Procedure](./bug-fix-procedure.md)
+- [Implementing new features](./implementing_new_features.md)
+- [Stability attributes](./stability.md)
+- [Stabilizing Features](./stabilization_guide.md)
+- [Feature Gates](./feature-gates.md)
+- [Coding conventions](./conventions.md)
+- [Notification groups](notification-groups/about.md)
+    - [ARM](notification-groups/arm.md)
+    - [Cleanup Crew](notification-groups/cleanup-crew.md)
+    - [LLVM](notification-groups/llvm.md)
+    - [RISC-V](notification-groups/risc-v.md)
+    - [Windows](notification-groups/windows.md)
+- [Licenses](./licenses.md)
+
+# High-level Compiler Architecture
+
+- [Prologue](./part-2-intro.md)
+- [Overview of the Compiler](./overview.md)
+- [The compiler source code](./compiler-src.md)
+- [Bootstrapping](./building/bootstrapping.md)
+- [Queries: demand-driven compilation](./query.md)
+    - [The Query Evaluation Model in Detail](./queries/query-evaluation-model-in-detail.md)
+    - [Incremental compilation](./queries/incremental-compilation.md)
+    - [Incremental compilation In Detail](./queries/incremental-compilation-in-detail.md)
+    - [Debugging and Testing](./incrcomp-debugging.md)
+    - [Salsa](./salsa.md)
+- [Memory Management in Rustc](./memory.md)
+- [Serialization in Rustc](./serialization.md)
+- [Parallel Compilation](./parallel-rustc.md)
+- [Rustdoc internals](./rustdoc-internals.md)
+
+# Source Code Representation
+
+- [Prologue](./part-3-intro.md)
+- [Command-line arguments](./cli.md)
+- [The Rustc Driver and Interface](./rustc-driver.md)
+    - [Example: Type checking](./rustc-driver-interacting-with-the-ast.md)
+    - [Example: Getting diagnostics](./rustc-driver-getting-diagnostics.md)
+- [Syntax and the AST](./syntax-intro.md)
+    - [Lexing and Parsing](./the-parser.md)
+    - [Macro expansion](./macro-expansion.md)
+    - [Name resolution](./name-resolution.md)
+    - [`#[test]` Implementation](./test-implementation.md)
+    - [Panic Implementation](./panic-implementation.md)
+    - [AST Validation](./ast-validation.md)
+    - [Feature Gate Checking](./feature-gate-ck.md)
+    - [Lang Items](./lang-items.md)
+- [The HIR (High-level IR)](./hir.md)
+    - [Lowering AST to HIR](./lowering.md)
+    - [Debugging](./hir-debugging.md)
+- [The THIR (Typed High-level IR)](./thir.md)
+- [The MIR (Mid-level IR)](./mir/index.md)
+    - [MIR construction](./mir/construction.md)
+    - [MIR visitor and traversal](./mir/visitor.md)
+    - [MIR passes: getting the MIR for a function](./mir/passes.md)
+- [Identifiers in the Compiler](./identifiers.md)
+- [Closure expansion](./closure.md)
+- [Inline assembly](./asm.md)
+
+# Analysis
+
+- [Prologue](./part-4-intro.md)
+- [The `ty` module: representing types](./ty.md)
+    - [Generics and substitutions](./generics.md)
+    - [`TypeFolder` and `TypeFoldable`](./ty-fold.md)
+    - [Generic arguments](./generic_arguments.md)
+    - [Constants in the type system](./constants.md)
+- [Type inference](./type-inference.md)
+- [Trait solving](./traits/resolution.md)
+    - [Early and Late Bound Parameters](./early-late-bound.md)
+    - [Higher-ranked trait bounds](./traits/hrtb.md)
+    - [Caching subtleties](./traits/caching.md)
+    - [Specialization](./traits/specialization.md)
+    - [Chalk-based trait solving](./traits/chalk.md)
+        - [Lowering to logic](./traits/lowering-to-logic.md)
+        - [Goals and clauses](./traits/goals-and-clauses.md)
+        - [Canonical queries](./traits/canonical-queries.md)
+- [Type checking](./type-checking.md)
+    - [Method Lookup](./method-lookup.md)
+    - [Variance](./variance.md)
+    - [Opaque Types](./opaque-types-type-alias-impl-trait.md)
+        - [Inference details](./opaque-types-impl-trait-inference.md)
+- [Pattern and Exhaustiveness Checking](./pat-exhaustive-checking.md)
+- [MIR dataflow](./mir/dataflow.md)
+- [Drop elaboration](./mir/drop-elaboration.md)
+- [The borrow checker](./borrow_check.md)
+    - [Tracking moves and initialization](./borrow_check/moves_and_initialization.md)
+        - [Move paths](./borrow_check/moves_and_initialization/move_paths.md)
+    - [MIR type checker](./borrow_check/type_check.md)
+    - [Region inference](./borrow_check/region_inference.md)
+        - [Constraint propagation](./borrow_check/region_inference/constraint_propagation.md)
+        - [Lifetime parameters](./borrow_check/region_inference/lifetime_parameters.md)
+        - [Member constraints](./borrow_check/region_inference/member_constraints.md)
+        - [Placeholders and universes][pau]
+        - [Closure constraints](./borrow_check/region_inference/closure_constraints.md)
+        - [Error reporting](./borrow_check/region_inference/error_reporting.md)
+    - [Two-phase-borrows](./borrow_check/two_phase_borrows.md)
+- [Parameter Environments](./param_env.md)
+- [Errors and Lints](diagnostics.md)
+    - [Diagnostic and subdiagnostic structs](./diagnostics/diagnostic-structs.md)
+    - [Translation](./diagnostics/translation.md)
+    - [`LintStore`](./diagnostics/lintstore.md)
+    - [Diagnostic codes](./diagnostics/diagnostic-codes.md)
+    - [Diagnostic items](./diagnostics/diagnostic-items.md)
+    - [`ErrorGuaranteed`](./diagnostics/error-guaranteed.md)
+
+# MIR to Binaries
+
+- [Prologue](./part-5-intro.md)
+- [MIR optimizations](./mir/optimizations.md)
+- [Debugging](./mir/debugging.md)
+- [Constant evaluation](./const-eval.md)
+    - [miri const evaluator](./miri.md)
+- [Monomorphization](./backend/monomorph.md)
+- [Lowering MIR](./backend/lowering-mir.md)
+- [Code Generation](./backend/codegen.md)
+    - [Updating LLVM](./backend/updating-llvm.md)
+    - [Debugging LLVM](./backend/debugging.md)
+    - [Backend Agnostic Codegen](./backend/backend-agnostic.md)
+    - [Implicit Caller Location](./backend/implicit-caller-location.md)
+- [Libraries and Metadata](./backend/libs-and-metadata.md)
+- [Profile-guided Optimization](./profile-guided-optimization.md)
+- [LLVM Source-Based Code Coverage](./llvm-coverage-instrumentation.md)
+- [Sanitizers Support](./sanitizers.md)
+- [Debugging Support in the Rust Compiler](./debugging-support-in-rustc.md)
+
+---
+
+[Appendix A: Background topics](./appendix/background.md)
+[Appendix B: Glossary](./appendix/glossary.md)
+[Appendix C: Code Index](./appendix/code-index.md)
+[Appendix D: Compiler Lecture Series](./appendix/compiler-lecture.md)
+[Appendix E: Bibliography](./appendix/bibliography.md)
+
+[Appendix Z: HumorRust](./appendix/humorust.md)
+
+---
+
+[pau]: ./borrow_check/region_inference/placeholders_and_universes.md
diff --git a/src/doc/rustc-dev-guide/src/about-this-guide.md b/src/doc/rustc-dev-guide/src/about-this-guide.md
new file mode 100644
index 000000000..b2c71866c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/about-this-guide.md
@@ -0,0 +1,71 @@
+# About this guide
+
+This guide is meant to help document how rustc – the Rust compiler – works,
+as well as to help new contributors get involved in rustc development.
+
+There are seven parts to this guide:
+
+1. [Building and debugging `rustc`][p1]:
+   Contains information that should be useful no matter how you are contributing,
+   about building, debugging, profiling, etc.
+2. [Contributing to `rustc`][p2]:
+   Contains information that should be useful no matter how you are contributing,
+   about procedures for contribution, using git and Github, stabilizing features, etc.
+3. [High-Level Compiler Architecture][p3]:
+   Discusses the high-level architecture of the compiler and stages of the compile process.
+4. [Source Code Representation][p4]:
+   Describes the process of taking raw source code from the user
+   and transforming it into various forms that the compiler can work with easily.
+5. [Analysis][p5]:
+   discusses the analyses that the compiler uses to check various properties of the code
+   and inform later stages of the compile process (e.g., type checking).
+6. [From MIR to Binaries][p6]: How linked executable machine code is generated.
+7. [Appendices][p7] at the end with useful reference information.
+   There are a few of these with different information, including a glossary.
+
+[p1]: ./getting-started.md
+[p2]: ./contributing.md
+[p3]: ./part-2-intro.md
+[p4]: ./part-3-intro.md
+[p5]: ./part-4-intro.md
+[p6]: ./part-5-intro.md
+[p7]: ./appendix/background.md
+
+### Constant change
+
+Keep in mind that `rustc` is a real production-quality product,
+being worked upon continuously by a sizeable set of contributors.
+As such, it has its fair share of codebase churn and technical debt.
+In addition, many of the ideas discussed throughout this guide are idealized designs
+that are not fully realized yet.
+All this makes keeping this guide completely up to date on everything very hard!
+
+The Guide itself is of course open-source as well,
+and the sources can be found at the [GitHub repository].
+If you find any mistakes in the guide, please file an issue about it.
+Even better, open a PR with a correction!
+
+If you do contribute to the guide,
+please see the corresponding [subsection on writing documentation in this guide].
+
+[subsection on writing documentation in this guide]: contributing.md#contributing-to-rustc-dev-guide
+
+> “‘All conditioned things are impermanent’ — 
+> when one sees this with wisdom, one turns away from suffering.”
+> _The Dhammapada, verse 277_
+
+## Other places to find information
+
+You might also find the following sites useful:
+
+- [rustc API docs] -- rustdoc documentation for the compiler
+- [Forge] -- contains documentation about Rust infrastructure, team procedures, and more
+- [compiler-team] -- the home-base for the Rust compiler team, with description
+  of the team procedures, active working groups, and the team calendar.
+- [std-dev-guide] -- a similar guide for developing the standard library.
+
+[GitHub repository]: https://github.com/rust-lang/rustc-dev-guide/
+[rustc API docs]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/
+[Forge]: https://forge.rust-lang.org/
+[compiler-team]: https://github.com/rust-lang/compiler-team/
+[std-dev-guide]: https://std-dev-guide.rust-lang.org/
diff --git a/src/doc/rustc-dev-guide/src/appendix/background.md b/src/doc/rustc-dev-guide/src/appendix/background.md
new file mode 100644
index 000000000..ae6136dd5
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/background.md
@@ -0,0 +1,332 @@
+# Background topics
+
+This section covers a numbers of common compiler terms that arise in
+this guide. We try to give the general definition while providing some
+Rust-specific context.
+
+<a name="cfg"></a>
+
+## What is a control-flow graph?
+
+A control-flow graph (CFG) is a common term from compilers. If you've ever
+used a flow-chart, then the concept of a control-flow graph will be
+pretty familiar to you. It's a representation of your program that
+clearly exposes the underlying control flow.
+
+A control-flow graph is structured as a set of **basic blocks**
+connected by edges. The key idea of a basic block is that it is a set
+of statements that execute "together" – that is, whenever you branch
+to a basic block, you start at the first statement and then execute
+all the remainder. Only at the end of the block is there the
+possibility of branching to more than one place (in MIR, we call that
+final statement the **terminator**):
+
+```mir
+bb0: {
+    statement0;
+    statement1;
+    statement2;
+    ...
+    terminator;
+}
+```
+
+Many expressions that you are used to in Rust compile down to multiple
+basic blocks. For example, consider an if statement:
+
+```rust,ignore
+a = 1;
+if some_variable {
+    b = 1;
+} else {
+    c = 1;
+}
+d = 1;
+```
+
+This would compile into four basic blocks in MIR. In textual form, it looks like
+this:
+
+```mir
+BB0: {
+    a = 1;
+    if some_variable {
+        goto BB1;
+    } else {
+        goto BB2;
+    }
+}
+
+BB1: {
+    b = 1;
+    goto BB3;
+}
+
+BB2: {
+    c = 1;
+    goto BB3;
+}
+
+BB3: {
+    d = 1;
+    ...
+}
+```
+
+In graphical form, it looks like this:
+
+```
+                BB0
+       +--------------------+
+       | a = 1;             |
+       +--------------------+
+             /       \
+  if some_variable   else
+           /           \
+     BB1  /             \  BB2
+    +-----------+   +-----------+
+    | b = 1;    |   | c = 1;    |
+    +-----------+   +-----------+
+            \          /
+             \        /
+              \ BB3  /
+            +----------+
+            | d = 1;   |
+            | ...      |
+            +----------+
+```
+
+When using a control-flow graph, a loop simply appears as a cycle in
+the graph, and the `break` keyword translates into a path out of that
+cycle.
+
+<a name="dataflow"></a>
+
+## What is a dataflow analysis?
+
+[*Static Program Analysis*](https://cs.au.dk/~amoeller/spa/) by Anders Møller
+and Michael I. Schwartzbach is an incredible resource!
+
+_Dataflow analysis_ is a type of static analysis that is common in many
+compilers. It describes a general technique, rather than a particular analysis.
+
+The basic idea is that we can walk over a [control-flow graph (CFG)](#cfg) and
+keep track of what some value could be. At the end of the walk, we might have
+shown that some claim is true or not necessarily true (e.g. "this variable must
+be initialized"). `rustc` tends to do dataflow analyses over the MIR, since MIR
+is already a CFG.
+
+For example, suppose we want to check that `x` is initialized before it is used
+in this snippet:
+
+```rust,ignore
+fn foo() {
+    let mut x;
+
+    if some_cond {
+        x = 1;
+    }
+
+    dbg!(x);
+}
+```
+
+A CFG for this code might look like this:
+
+```txt
+ +------+
+ | Init | (A)
+ +------+
+    |   \
+    |   if some_cond
+  else    \ +-------+
+    |      \| x = 1 | (B)
+    |       +-------+
+    |      /
+ +---------+
+ | dbg!(x) | (C)
+ +---------+
+```
+
+We can do the dataflow analysis as follows: we will start off with a flag `init`
+which indicates if we know `x` is initialized. As we walk the CFG, we will
+update the flag. At the end, we can check its value.
+
+So first, in block (A), the variable `x` is declared but not initialized, so
+`init = false`. In block (B), we initialize the value, so we know that `x` is
+initialized. So at the end of (B), `init = true`.
+
+Block (C) is where things get interesting. Notice that there are two incoming
+edges, one from (A) and one from (B), corresponding to whether `some_cond` is true or not.
+But we cannot know that! It could be the case the `some_cond` is always true,
+so that `x` is actually always initialized. It could also be the case that
+`some_cond` depends on something random (e.g. the time), so `x` may not be
+initialized. In general, we cannot know statically (due to [Rice's
+Theorem][rice]).  So what should the value of `init` be in block (C)?
+
+[rice]: https://en.wikipedia.org/wiki/Rice%27s_theorem
+
+Generally, in dataflow analyses, if a block has multiple parents (like (C) in
+our example), its dataflow value will be some function of all its parents (and
+of course, what happens in (C)).  Which function we use depends on the analysis
+we are doing.
+
+In this case, we want to be able to prove definitively that `x` must be
+initialized before use. This forces us to be conservative and assume that
+`some_cond` might be false sometimes. So our "merging function" is "and". That
+is, `init = true` in (C) if `init = true` in (A) _and_ in (B) (or if `x` is
+initialized in (C)). But this is not the case; in particular, `init = false` in
+(A), and `x` is not initialized in (C).  Thus, `init = false` in (C); we can
+report an error that "`x` may not be initialized before use".
+
+There is definitely a lot more that can be said about dataflow analyses. There is an
+extensive body of research literature on the topic, including a lot of theory.
+We only discussed a forwards analysis, but backwards dataflow analysis is also
+useful. For example, rather than starting from block (A) and moving forwards,
+we might have started with the usage of `x` and moved backwards to try to find
+its initialization.
+
+<a name="quantified"></a>
+
+## What is "universally quantified"? What about "existentially quantified"?
+
+In math, a predicate may be _universally quantified_ or _existentially
+quantified_:
+
+- _Universal_ quantification:
+  - the predicate holds if it is true for all possible inputs.
+  - Traditional notation: ∀x: P(x). Read as "for all x, P(x) holds".
+- _Existential_ quantification:
+  - the predicate holds if there is any input where it is true, i.e., there
+    only has to be a single input.
+  - Traditional notation: ∃x: P(x). Read as "there exists x such that P(x) holds".
+
+In Rust, they come up in type checking and trait solving. For example,
+
+```rust,ignore
+fn foo<T>()
+```
+This function claims that the function is well-typed for all types `T`: `∀ T: well_typed(foo)`.
+
+Another example:
+
+```rust,ignore
+fn foo<'a>(_: &'a usize)
+```
+This function claims that for any lifetime `'a` (determined by the
+caller), it is well-typed: `∀ 'a: well_typed(foo)`.
+
+Another example:
+
+```rust,ignore
+fn foo<F>()
+where for<'a> F: Fn(&'a u8)
+```
+This function claims that it is well-typed for all types `F` such that for all
+lifetimes `'a`, `F: Fn(&'a u8)`: `∀ F: ∀ 'a: (F: Fn(&'a u8)) => well_typed(foo)`.
+
+One more example:
+
+```rust,ignore
+fn foo(_: dyn Debug)
+```
+This function claims that there exists some type `T` that implements `Debug`
+such that the function is well-typed: `∃ T:  (T: Debug) and well_typed(foo)`.
+
+<a name="variance"></a>
+
+## What is a de Bruijn Index?
+
+[De Bruijn indices][wikideb] are a way of representing, using only integers,
+which variables are bound in which binders. They were originally invented for
+use in lambda calculus evaluation (see [this Wikipedia article][wikideb] for
+more). In `rustc`, we use de Bruijn indices to [represent generic types][sub].
+
+[wikideb]: https://en.wikipedia.org/wiki/De_Bruijn_index
+[sub]: ../generics.md
+
+Here is a basic example of how de Bruijn indices might be used for closures (we
+don't actually do this in `rustc` though!):
+
+```rust,ignore
+|x| {
+    f(x) // de Bruijn index of `x` is 1 because `x` is bound 1 level up
+
+    |y| {
+        g(x, y) // index of `x` is 2 because it is bound 2 levels up
+                // index of `y` is 1 because it is bound 1 level up
+    }
+}
+```
+
+## What are co- and contra-variance?
+
+Check out the subtyping chapter from the
+[Rust Nomicon](https://doc.rust-lang.org/nomicon/subtyping.html).
+
+See the [variance](../variance.html) chapter of this guide for more info on how
+the type checker handles variance.
+
+<a name="free-vs-bound"></a>
+
+## What is a "free region" or a "free variable"? What about "bound region"?
+
+Let's describe the concepts of free vs bound in terms of program
+variables, since that's the thing we're most familiar with.
+
+- Consider this expression, which creates a closure: `|a, b| a + b`.
+  Here, the `a` and `b` in `a + b` refer to the arguments that the closure will
+  be given when it is called. We say that the `a` and `b` there are **bound** to
+  the closure, and that the closure signature `|a, b|` is a **binder** for the
+  names `a` and `b` (because any references to `a` or `b` within refer to the
+  variables that it introduces).
+- Consider this expression: `a + b`. In this expression, `a` and `b` refer to
+  local variables that are defined *outside* of the expression. We say that
+  those variables **appear free** in the expression (i.e., they are **free**,
+  not **bound** (tied up)).
+
+So there you have it: a variable "appears free" in some
+expression/statement/whatever if it refers to something defined
+outside of that expressions/statement/whatever. Equivalently, we can
+then refer to the "free variables" of an expression – which is just
+the set of variables that "appear free".
+
+So what does this have to do with regions? Well, we can apply the
+analogous concept to type and regions. For example, in the type `&'a
+u32`, `'a` appears free.  But in the type `for<'a> fn(&'a u32)`, it
+does not.
+
+# Further Reading About Compilers
+
+> Thanks to `mem`, `scottmcm`, and `Levi` on the official Discord for the
+> recommendations, and to `tinaun` for posting a link to a [twitter thread from
+> Graydon Hoare](https://twitter.com/graydon_pub/status/1039615569132118016)
+> which had some more recommendations!
+>
+> Other sources: https://gcc.gnu.org/wiki/ListOfCompilerBooks
+>
+> If you have other suggestions, please feel free to open an issue or PR.
+
+## Books
+- [Types and Programming Languages](https://www.cis.upenn.edu/~bcpierce/tapl/)
+- [Programming Language Pragmatics](https://www.cs.rochester.edu/~scott/pragmatics/)
+- [Practical Foundations for Programming Languages](https://www.cs.cmu.edu/~rwh/pfpl/2nded.pdf)
+- [Compilers: Principles, Techniques, and Tools, 2nd Edition](https://www.pearson.com/us/higher-education/program/Aho-Compilers-Principles-Techniques-and-Tools-2nd-Edition/PGM167067.html)
+- [Garbage Collection: Algorithms for Automatic Dynamic Memory Management](https://www.cs.kent.ac.uk/people/staff/rej/gcbook/)
+- [Linkers and Loaders](https://www.amazon.com/Linkers-Kaufmann-Software-Engineering-Programming/dp/1558604960) (There are also free versions of this, but the version we had linked seems to be offline at the moment.)
+- [Advanced Compiler Design and Implementation](https://www.goodreads.com/book/show/887908.Advanced_Compiler_Design_and_Implementation)
+- [Building an Optimizing Compiler](https://www.goodreads.com/book/show/2063103.Building_an_Optimizing_Compiler)
+- [Crafting Interpreters](http://www.craftinginterpreters.com/)
+
+## Courses
+- [University of Oregon Programming Languages Summer School archive](https://www.cs.uoregon.edu/research/summerschool/archives.html)
+
+## Wikis
+- [Wikipedia](https://en.wikipedia.org/wiki/List_of_programming_languages_by_type)
+- [Esoteric Programming Languages](https://esolangs.org/wiki/Main_Page)
+- [Stanford Encyclopedia of Philosophy](https://plato.stanford.edu/index.html)
+- [nLab](https://ncatlab.org/nlab/show/HomePage)
+
+## Misc Papers and Blog Posts
+- [Programming in Martin-Löf's Type Theory](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.118.6683&rep=rep1&type=pdf)
+- [Polymorphism, Subtyping, and Type Inference in MLsub](https://dl.acm.org/doi/10.1145/3093333.3009882)
diff --git a/src/doc/rustc-dev-guide/src/appendix/bibliography.md b/src/doc/rustc-dev-guide/src/appendix/bibliography.md
new file mode 100644
index 000000000..27529314c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/bibliography.md
@@ -0,0 +1,92 @@
+# Rust Bibliography
+
+This is a reading list of material relevant to Rust. It includes prior
+research that has - at one time or another - influenced the design of
+Rust, as well as publications about Rust.
+
+## Type system
+
+* [Region based memory management in Cyclone](https://www.cs.umd.edu/projects/cyclone/papers/cyclone-regions.pdf)
+* [Safe manual memory management in Cyclone](https://www.cs.umd.edu/projects/PL/cyclone/scp.pdf)
+* [Making ad-hoc polymorphism less ad hoc](https://dl.acm.org/doi/10.1145/75277.75283)
+* [Macros that work together](https://www.cs.utah.edu/plt/publications/jfp12-draft-fcdf.pdf)
+* [Traits: composable units of behavior](http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf)
+* [Alias burying](https://dl.acm.org/doi/10.1002/spe.370) - We tried something similar and abandoned it.
+* [External uniqueness is unique enough](http://www.cs.uu.nl/research/techreps/UU-CS-2002-048.html)
+* [Uniqueness and Reference Immutability for Safe Parallelism](https://research.microsoft.com/pubs/170528/msr-tr-2012-79.pdf)
+* [Region Based Memory Management](https://www.cs.ucla.edu/~palsberg/tba/papers/tofte-talpin-iandc97.pdf)
+
+## Concurrency
+
+* [Singularity: rethinking the software stack](https://research.microsoft.com/pubs/69431/osr2007_rethinkingsoftwarestack.pdf)
+* [Language support for fast and reliable message passing in singularity OS](https://research.microsoft.com/pubs/67482/singsharp.pdf)
+* [Scheduling multithreaded computations by work stealing](http://supertech.csail.mit.edu/papers/steal.pdf)
+* [Thread scheduling for multiprogramming multiprocessors](https://www.eecis.udel.edu/%7Ecavazos/cisc879-spring2008/papers/arora98thread.pdf)
+* [The data locality of work stealing](http://www.aladdin.cs.cmu.edu/papers/pdfs/y2000/locality_spaa00.pdf)
+* [Dynamic circular work stealing deque](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.1097&rep=rep1&type=pdf) - The Chase/Lev deque
+* [Work-first and help-first scheduling policies for async-finish task parallelism](https://dl.acm.org/doi/10.1109/IPDPS.2009.5161079) - More general than fully-strict work stealing
+* [A Java fork/join calamity](https://web.archive.org/web/20190904045322/http://www.coopsoft.com/ar/CalamityArticle.html) - critique of Java's fork/join library, particularly its application of work stealing to non-strict computation
+* [Scheduling techniques for concurrent systems](https://www.stanford.edu/~ouster/cgi-bin/papers/coscheduling.pdf)
+* [Contention aware scheduling](https://www.blagodurov.net/files/a8-blagodurov.pdf)
+* [Balanced work stealing for time-sharing multicores](https://web.njit.edu/~dingxn/papers/BWS.pdf)
+* [Three layer cake for shared-memory programming](https://dl.acm.org/doi/10.1145/1953611.1953616)
+* [Non-blocking steal-half work queues](https://www.cs.bgu.ac.il/%7Ehendlerd/papers/p280-hendler.pdf)
+* [Reagents: expressing and composing fine-grained concurrency](https://aturon.github.io/academic/reagents.pdf)
+* [Algorithms for scalable synchronization of shared-memory multiprocessors](https://www.cs.rochester.edu/u/scott/papers/1991_TOCS_synch.pdf)
+* [Epoch-based reclamation](https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-579.pdf).
+
+## Others
+
+* [Crash-only software](https://www.usenix.org/legacy/events/hotos03/tech/full_papers/candea/candea.pdf)
+* [Composing High-Performance Memory Allocators](https://people.cs.umass.edu/~emery/pubs/berger-pldi2001.pdf)
+* [Reconsidering Custom Memory Allocation](https://people.cs.umass.edu/~emery/pubs/berger-oopsla2002.pdf)
+
+## Papers *about* Rust
+
+* [GPU Programming in Rust: Implementing High Level Abstractions in a Systems
+  Level
+  Language](https://ieeexplore.ieee.org/document/6650903).
+  Early GPU work by Eric Holk.
+* [Parallel closures: a new twist on an old
+  idea](https://www.usenix.org/conference/hotpar12/parallel-closures-new-twist-old-idea)
+  - not exactly about Rust, but by nmatsakis
+* [Patina: A Formalization of the Rust Programming
+  Language](https://dada.cs.washington.edu/research/tr/2015/03/UW-CSE-15-03-02.pdf).
+  Early formalization of a subset of the type system, by Eric Reed.
+* [Experience Report: Developing the Servo Web Browser Engine using
+  Rust](https://arxiv.org/abs/1505.07383). By Lars Bergstrom.
+* [Implementing a Generic Radix Trie in
+  Rust](https://michaelsproul.github.io/rust_radix_paper/rust-radix-sproul.pdf). Undergrad
+  paper by Michael Sproul.
+* [Reenix: Implementing a Unix-Like Operating System in
+  Rust](https://scialex.github.io/reenix.pdf). Undergrad paper by Alex
+  Light.
+* [Evaluation of performance and productivity metrics of potential programming languages in the HPC environment](https://github.com/1wilkens/thesis-ba).
+  Bachelor's thesis by Florian Wilkens. Compares C, Go and Rust.
+* [Nom, a byte oriented, streaming, zero copy, parser combinators library
+  in Rust](http://spw15.langsec.org/papers/couprie-nom.pdf). By
+  Geoffroy Couprie, research for VLC.
+* [Graph-Based Higher-Order Intermediate
+  Representation](https://compilers.cs.uni-saarland.de/papers/lkh15_cgo.pdf). An
+  experimental IR implemented in Impala, a Rust-like language.
+* [Code Refinement of Stencil
+  Codes](https://compilers.cs.uni-saarland.de/papers/ppl14_web.pdf). Another
+  paper using Impala.
+* [Parallelization in Rust with fork-join and
+  friends](http://publications.lib.chalmers.se/records/fulltext/219016/219016.pdf). Linus
+  Farnstrand's master's thesis.
+* [Session Types for
+  Rust](https://munksgaard.me/papers/laumann-munksgaard-larsen.pdf). Philip
+  Munksgaard's master's thesis. Research for Servo.
+* [Ownership is Theft: Experiences Building an Embedded OS in Rust - Amit Levy, et. al.](https://amitlevy.com/papers/tock-plos2015.pdf)
+* [You can't spell trust without Rust](https://raw.githubusercontent.com/Gankro/thesis/master/thesis.pdf). Alexis Beingessner's master's thesis.
+* [Rust-Bio: a fast and safe bioinformatics library](https://academic.oup.com/bioinformatics/article/32/3/444/1743419). Johannes Köster
+* [Safe, Correct, and Fast Low-Level Networking](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.704.1768). Robert Clipsham's master's thesis.
+* [Formalizing Rust traits](https://open.library.ubc.ca/cIRcle/collections/ubctheses/24/items/1.0220521). Jonatan Milewski's master's thesis.
+* [Rust as a Language for High Performance GC Implementation](https://users.cecs.anu.edu.au/~steveb/downloads/pdf/rust-ismm-2016.pdf)
+* [Simple Verification of Rust Programs via Functional Purification](https://github.com/Kha/electrolysis). Sebastian Ullrich's master's thesis.
+* [Writing parsers like it is 2017](http://spw17.langsec.org/papers/chifflier-parsing-in-2017.pdf) Pierre Chifflier and Geoffroy Couprie for the Langsec Workshop
+* [The Case for Writing a Kernel in Rust](https://www.tockos.org/assets/papers/rust-kernel-apsys2017.pdf)
+* [RustBelt: Securing the Foundations of the Rust Programming Language](https://plv.mpi-sws.org/rustbelt/popl18/)
+* [Oxide: The Essence of Rust](https://arxiv.org/abs/1903.00982). By Aaron Weiss, Olek Gierczak, Daniel Patterson, Nicholas D. Matsakis, and Amal Ahmed.
+* [Polymorphisation: Improving Rust compilation times through intelligent monomorphisation](https://davidtw.co/media/masters_dissertation.pdf). David Wood's master's thesis.
diff --git a/src/doc/rustc-dev-guide/src/appendix/code-index.md b/src/doc/rustc-dev-guide/src/appendix/code-index.md
new file mode 100644
index 000000000..f645c0118
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/code-index.md
@@ -0,0 +1,45 @@
+# Code Index
+
+rustc has a lot of important data structures. This is an attempt to give some
+guidance on where to learn more about some of the key data structures of the
+compiler.
+
+Item            |  Kind    | Short description           | Chapter            | Declaration
+----------------|----------|-----------------------------|--------------------|-------------------
+`BodyId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/hir.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.BodyId.html)
+`Compiler` | struct | Represents a compiler session and can be used to drive a compilation. | [The Rustc Driver and Interface] | [compiler/rustc_interface/src/interface.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/struct.Compiler.html)
+`ast::Crate` | struct | A syntax-level representation of a parsed crate | [The parser] | [compiler/rustc_ast/src/ast.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/struct.Crate.html)
+`rustc_hir::Crate` | struct | A more abstract, compiler-friendly form of a crate's AST | [The Hir] | [compiler/rustc_hir/src/hir.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Crate.html)
+`DefId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/def_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html)
+`DiagnosticBuilder` | struct | A struct for building up compiler diagnostics, such as errors or lints | [Emitting Diagnostics] | [compiler/rustc_errors/src/diagnostic_builder.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.DiagnosticBuilder.html)
+`DocContext` | struct | A state container used by rustdoc when crawling through a crate to gather its documentation | [Rustdoc] | [src/librustdoc/core.rs](https://github.com/rust-lang/rust/blob/master/src/librustdoc/core.rs)
+`HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/hir_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir_id/struct.HirId.html)
+`NodeId` | struct | One of four types of HIR node identifiers. Being phased out | [Identifiers in the HIR] | [compiler/rustc_ast/src/ast.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html)
+`P` | struct | An owned immutable smart pointer. By contrast, `&T` is not owned, and `Box<T>` is not immutable. | None | [compiler/rustc_ast/src/ptr.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ptr/struct.P.html)
+`ParamEnv` | struct | Information about generic parameters or `Self`, useful for working with associated or generic items | [Parameter Environment] | [compiler/rustc_middle/src/ty/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamEnv.html)
+`ParseSess` | struct | This struct contains information about a parsing session | [The parser] | [compiler/rustc_session/src/parse/parse.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/parse/struct.ParseSess.html)
+`Query` | struct | Represents the result of query to the `Compiler` interface and allows stealing, borrowing, and returning the results of compiler passes. | [The Rustc Driver and Interface] | [compiler/rustc_interface/src/queries.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/queries/struct.Query.html)
+`Rib` | struct | Represents a single scope of names | [Name resolution] | [compiler/rustc_resolve/src/lib.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/late/struct.Rib.html)
+`Session` | struct | The data associated with a compilation session | [The parser], [The Rustc Driver and Interface] | [compiler/rustc_session/src/session.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html)
+`SourceFile` | struct | Part of the `SourceMap`. Maps AST nodes to their source code for a single source file. Was previously called FileMap | [The parser] | [compiler/rustc_span/src/lib.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.SourceFile.html)
+`SourceMap` | struct | Maps AST nodes to their source code. It is composed of `SourceFile`s. Was previously called CodeMap | [The parser] | [compiler/rustc_span/src/source_map.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/source_map/struct.SourceMap.html)
+`Span` | struct  | A location in the user's source code, used for error reporting primarily | [Emitting Diagnostics] | [compiler/rustc_span/src/span_encoding.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html)
+`StringReader` | struct | This is the lexer used during parsing. It consumes characters from the raw source code being compiled and produces a series of tokens for use by the rest of the parser | [The parser] |  [compiler/rustc_parse/src/lexer/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.StringReader.html)
+`rustc_ast::token_stream::TokenStream` | struct | An abstract sequence of tokens, organized into `TokenTree`s | [The parser], [Macro expansion] | [compiler/rustc_ast/src/tokenstream.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/tokenstream/struct.TokenStream.html)
+`TraitDef` | struct | This struct contains a trait's definition with type information | [The `ty` modules] |  [compiler/rustc_middle/src/ty/trait_def.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait_def/struct.TraitDef.html)
+`TraitRef` | struct | The combination of a trait and its input types (e.g. `P0: Trait<P1...Pn>`) | [Trait Solving: Goals and Clauses]  |  [compiler/rustc_middle/src/ty/sty.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TraitRef.html)
+`Ty<'tcx>` | struct | This is the internal representation of a type used for type checking | [Type checking] | [compiler/rustc_middle/src/ty/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html)
+`TyCtxt<'tcx>` | struct | The "typing context". This is the central data structure in the compiler. It is the context that you use to perform all manner of queries | [The `ty` modules] | [compiler/rustc_middle/src/ty/context.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html)
+
+[The HIR]: ../hir.html
+[Identifiers in the HIR]: ../hir.html#hir-id
+[The parser]: ../the-parser.html
+[The Rustc Driver and Interface]: ../rustc-driver.html
+[Type checking]: ../type-checking.html
+[The `ty` modules]: ../ty.html
+[Rustdoc]: ../rustdoc.html
+[Emitting Diagnostics]: ../diagnostics.html
+[Macro expansion]: ../macro-expansion.html
+[Name resolution]: ../name-resolution.html
+[Parameter Environment]: ../param_env.html
+[Trait Solving: Goals and Clauses]: ../traits/goals-and-clauses.html#domain-goals
diff --git a/src/doc/rustc-dev-guide/src/appendix/compiler-lecture.md b/src/doc/rustc-dev-guide/src/appendix/compiler-lecture.md
new file mode 100644
index 000000000..dabd2f087
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/compiler-lecture.md
@@ -0,0 +1,48 @@
+# Compiler Lecture Series
+
+These are videos where various experts explain different parts of the compiler:
+
+## General
+- [January 2019: Tom Tromey discusses debugging support in rustc](https://www.youtube.com/watch?v=elBxMRSNYr4)
+- [June 2019: Responsive compilers - Nicholas Matsakis - PLISS 2019](https://www.youtube.com/watch?v=N6b44kMS6OM)
+- [June 2019: Things I Learned (TIL) - Nicholas Matsakis - PLISS 2019](https://www.youtube.com/watch?v=LIYkT3p5gTs)
+
+## Rust Analyzer
+- [January 2019: How Salsa Works](https://www.youtube.com/watch?v=_muY4HjSqVw)
+- [January 2019: Salsa In More Depth](https://www.youtube.com/watch?v=i_IhACacPRY)
+- [January 2019: Rust analyzer guide](https://www.youtube.com/watch?v=ANKBNiSWyfc)
+- [February 2019: Rust analyzer syntax trees](https://www.youtube.com/watch?v=DGAuLWdCCAI)
+- [March 2019: rust-analyzer type-checker overview by flodiebold](https://www.youtube.com/watch?v=Lmp3P9WNL8o)
+- [March 2019: RLS 2.0, Salsa, and Name Resolution](https://www.youtube.com/watch?v=Xr-rBqLr-G4)
+
+## Type System
+- [July 2015: Felix Klock - Rust: A type system you didn't know you wanted - Curry On](https://www.youtube.com/watch?v=Q7lQCgnNWU0)
+- [November 2016: Felix Klock - Subtyping in Rust and Clarke's Third Law](https://www.youtube.com/watch?v=fI4RG_uq-WU)
+- [February 2019: Universes and Lifetimes](https://www.youtube.com/watch?v=iV1Z0xYXkck)
+- [April 2019: Representing types in rustc](https://www.youtube.com/watch?v=c01TsOsr3-c)
+- [March 2019: RFC #2229 Disjoint Field Capture plan](https://www.youtube.com/watch?v=UTXOptVMuIc)
+
+## Closures
+- [October 2018: closures and upvar capture](https://www.youtube.com/watch?v=fMopdkn5-Xw)
+- [October 2018: blitzerr closure upvar tys](https://www.youtube.com/watch?v=pLmVhSB-z4s)
+- [January 2019: Convert Closure Upvar Representation to Tuples with blitzerr](https://www.youtube.com/watch?v=2QCuNtISoYc)
+
+## Chalk
+- [July 2018: Coherence in Chalk by Sunjay Varma - Bay Area Rust Meetup](https://www.youtube.com/watch?v=rZqS4bLPL24)
+- [March 2019: rustc-chalk integration overview](https://www.youtube.com/watch?v=MBWtbDifPeU)
+- [April 2019: How the chalk-engine crate works](https://www.youtube.com/watch?v=Ny2928cGDoM)
+- [May 2019: How the chalk-engine crate works 2](https://www.youtube.com/watch?v=hmV66tB79LM)
+
+## Polonius
+- [March 2019: Polonius-rustc walkthrough](https://www.youtube.com/watch?v=i5KdU0ieb_A)
+- [May 2019: Polonius WG: Initialization and move tracking](https://www.youtube.com/watch?v=ilv9V-328HI)
+
+## Miri
+- [March 2019: oli-obk on miri and constant evaluation](https://www.youtube.com/watch?v=5Pm2C1YXrvM)
+
+## Async
+- [February 2019: async-await implementation plans](https://www.youtube.com/watch?v=xe2_whJWBC0)
+- [April 2019: async-await region inferencer](https://www.youtube.com/watch?v=hlOxfkUDLPQ)
+
+## Code Generation
+- [January 2019: Cranelift](https://www.youtube.com/watch?v=9OIA7DTFQWU)
diff --git a/src/doc/rustc-dev-guide/src/appendix/glossary.md b/src/doc/rustc-dev-guide/src/appendix/glossary.md
new file mode 100644
index 000000000..375db493c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/glossary.md
@@ -0,0 +1,98 @@
+# Glossary
+
+<!-- &nbsp;s are a workaround for https://github.com/badboy/mdbook-toc/issues/19 -->
+Term                                                  | Meaning
+------------------------------------------------------|--------
+<span id="arena">arena/arena allocation</span> &nbsp; |  An _arena_ is a large memory buffer from which other memory allocations are made. This style of allocation is called _arena allocation_. See [this chapter](../memory.md) for more info.
+<span id="ast">AST</span>                      &nbsp; |  The abstract syntax tree produced by the `rustc_ast` crate; reflects user syntax very closely.
+<span id="binder">binder</span>                &nbsp; |  A "binder" is a place where a variable or type is declared; for example, the `<T>` is a binder for the generic type parameter `T` in `fn foo<T>(..)`, and \|`a`\|` ...` is a binder for the parameter `a`. See [the background chapter for more](./background.md#free-vs-bound).
+<span id="body-id">BodyId</span>               &nbsp; |  An identifier that refers to a specific body (definition of a function or constant) in the crate. See [the HIR chapter for more](../hir.md#identifiers-in-the-hir).
+<span id="bound-var">bound variable</span>     &nbsp; |  A "bound variable" is one that is declared within an expression/term. For example, the variable `a` is bound within the closure expression \|`a`\|` a * 2`. See [the background chapter for more](./background.md#free-vs-bound)
+<span id="codegen">codegen</span>              &nbsp; |  The code to translate MIR into LLVM IR.
+<span id="codegen-unit">codegen unit</span>    &nbsp; |  When we produce LLVM IR, we group the Rust code into a number of codegen units (sometimes abbreviated as CGUs). Each of these units is processed by LLVM independently from one another, enabling parallelism. They are also the unit of incremental re-use. ([see more](../backend/codegen.md))
+<span id="completeness">completeness</span>    &nbsp; |  A technical term in type theory, it means that every type-safe program also type-checks. Having both soundness and completeness is very hard, and usually soundness is more important. (see "soundness").
+<span id="cfg">control-flow graph</span>       &nbsp; |  A representation of the control-flow of a program; see [the background chapter for more](./background.md#cfg)
+<span id="ctfe">CTFE</span>                    &nbsp; |  Short for Compile-Time Function Evaluation, this is the ability of the compiler to evaluate `const fn`s at compile time. This is part of the compiler's constant evaluation system. ([see more](../const-eval.md))
+<span id="cx">cx</span>                        &nbsp; |  We tend to use "cx" as an abbreviation for context. See also `tcx`, `infcx`, etc.
+<span id="ctxt">ctxt</span>                    &nbsp; |  We also use "ctxt" as an abbreviation for context, e.g. [`TyCtxt`](#TyCtxt). See also [cx](#cx) or [tcx](#tcx).
+<span id="dag">DAG</span>                      &nbsp; |  A directed acyclic graph is used during compilation to keep track of dependencies between queries. ([see more](../queries/incremental-compilation.md))
+<span id="data-flow">data-flow analysis</span> &nbsp; |  A static analysis that figures out what properties are true at each point in the control-flow of a program; see [the background chapter for more](./background.md#dataflow).
+<span id="debruijn">DeBruijn Index</span>      &nbsp; |  A technique for describing which binder a variable is bound by using only integers. It has the benefit that it is invariant under variable renaming. ([see more](./background.md#what-is-a-debruijn-index))
+<span id="def-id">`DefId`</span>               &nbsp; |  An index identifying a definition (see `rustc_middle/src/hir/def_id.rs`). Uniquely identifies a `DefPath`. See [the HIR chapter for more](../hir.md#identifiers-in-the-hir).
+<span id="discriminant">discriminant</span>    &nbsp; |  The underlying value associated with an enum variant or generator state to indicate it as "active" (but not to be confused with its ["variant index"](#variant-idx)). At runtime, the discriminant of the active variant is encoded in the [tag](#tag).
+<span id="double-ptr">double pointer</span>    &nbsp; |  A pointer with additional metadata. See "fat pointer" for more.
+<span id="drop-glue">drop glue</span>          &nbsp; |  (internal) compiler-generated instructions that handle calling the destructors (`Drop`) for data types.
+<span id="dst">DST</span>                      &nbsp; |  Short for Dynamically-Sized Type, this is a type for which the compiler cannot statically know the size in memory (e.g. `str` or `[u8]`). Such types don't implement `Sized` and cannot be allocated on the stack. They can only occur as the last field in a struct. They can only be used behind a pointer (e.g. `&str` or `&[u8]`).
+<span id="ebl">early-bound lifetime</span>     &nbsp; |  A lifetime region that is substituted at its definition site. Bound in an item's `Generics` and substituted using a `Substs`. Contrast with **late-bound lifetime**. ([see more](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.RegionKind.html#bound-regions))
+<span id="empty-type">empty type</span>        &nbsp; |  see "uninhabited type".
+<span id="fat-ptr">fat pointer</span>          &nbsp; |  A two word value carrying the address of some value, along with some further information necessary to put the value to use. Rust includes two kinds of "fat pointers": references to slices, and trait objects. A reference to a slice carries the starting address of the slice and its length. A trait object carries a value's address and a pointer to the trait's implementation appropriate to that value. "Fat pointers" are also known as "wide pointers", and "double pointers".
+<span id="free-var">free variable</span>       &nbsp; |  A "free variable" is one that is not bound within an expression or term; see [the background chapter for more](./background.md#free-vs-bound)
+<span id="generics">generics</span>            &nbsp; |  The set of generic type parameters defined on a type or item.
+<span id="hir">HIR</span>                      &nbsp; |  The High-level IR, created by lowering and desugaring the AST. ([see more](../hir.md))
+<span id="hir-id">`HirId`</span>               &nbsp; |  Identifies a particular node in the HIR by combining a def-id with an "intra-definition offset". See [the HIR chapter for more](../hir.md#identifiers-in-the-hir).
+<span id="hir-map">HIR map</span>              &nbsp; |  The HIR map, accessible via `tcx.hir()`, allows you to quickly navigate the HIR and convert between various forms of identifiers.
+<span id="ice">ICE</span>                      &nbsp; |  Short for internal compiler error, this is when the compiler crashes.
+<span id="ich">ICH</span>                      &nbsp; |  Short for incremental compilation hash, these are used as fingerprints for things such as HIR and crate metadata, to check if changes have been made. This is useful in incremental compilation to see if part of a crate has changed and should be recompiled.
+<span id="infcx">infcx</span>                  &nbsp; |  The type inference context (`InferCtxt`). (see `rustc_middle::infer`)
+<span id="inf-var">inference variable</span>   &nbsp; |  When doing type or region inference, an "inference variable" is a kind of special type/region that represents what you are trying to infer. Think of X in algebra. For example, if we are trying to infer the type of a variable in a program, we create an inference variable to represent that unknown type.
+<span id="intern">intern</span>                &nbsp; |  Interning refers to storing certain frequently-used constant data, such as strings, and then referring to the data by an identifier (e.g. a `Symbol`) rather than the data itself, to reduce memory usage and number of allocations. See [this chapter](../memory.md) for more info.
+<span id="intrinsic">intrinsic</span>          &nbsp; |  Intrinsics are special functions that are implemented in the compiler itself but exposed (often unstably) to users. They do magical and dangerous things. (See [`std::intrinsics`](https://doc.rust-lang.org/std/intrinsics/index.html))
+<span id="ir">IR</span>                        &nbsp; |  Short for Intermediate Representation, a general term in compilers. During compilation, the code is transformed from raw source (ASCII text) to various IRs. In Rust, these are primarily HIR, MIR, and LLVM IR. Each IR is well-suited for some set of computations. For example, MIR is well-suited for the borrow checker, and LLVM IR is well-suited for codegen because LLVM accepts it.
+<span id="irlo">IRLO</span>                    &nbsp; |  `IRLO` or `irlo` is sometimes used as an abbreviation for [internals.rust-lang.org](https://internals.rust-lang.org).
+<span id="item">item</span>                    &nbsp; |  A kind of "definition" in the language, such as a static, const, use statement, module, struct, etc. Concretely, this corresponds to the `Item` type.
+<span id="lang-item">lang item</span>          &nbsp; |  Items that represent concepts intrinsic to the language itself, such as special built-in traits like `Sync` and `Send`; or traits representing operations such as `Add`; or functions that are called by the compiler. ([see more](https://doc.rust-lang.org/1.9.0/book/lang-items.html))
+<span id="lbl">late-bound lifetime</span>      &nbsp; |  A lifetime region that is substituted at its call site. Bound in a HRTB and substituted by specific functions in the compiler, such as `liberate_late_bound_regions`. Contrast with **early-bound lifetime**. ([see more](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.RegionKind.html#bound-regions))
+<span id="local-crate">local crate</span>      &nbsp; |  The crate currently being compiled. This is in contrast to "upstream crates" which refer to dependencies of the local crate.
+<span id="lto">LTO</span>                      &nbsp; |  Short for Link-Time Optimizations, this is a set of optimizations offered by LLVM that occur just before the final binary is linked. These include optimizations like removing functions that are never used in the final program, for example. _ThinLTO_ is a variant of LTO that aims to be a bit more scalable and efficient, but possibly sacrifices some optimizations. You may also read issues in the Rust repo about "FatLTO", which is the loving nickname given to non-Thin LTO. LLVM documentation: [here][lto] and [here][thinlto].
+<span id="llvm">[LLVM]</span>                  &nbsp; |  (actually not an acronym :P) an open-source compiler backend. It accepts LLVM IR and outputs native binaries. Various languages (e.g. Rust) can then implement a compiler front-end that outputs LLVM IR and use LLVM to compile to all the platforms LLVM supports.
+<span id="memoization">memoization</span>      &nbsp; |  The process of storing the results of (pure) computations (such as pure function calls) to avoid having to repeat them in the future. This is typically a trade-off between execution speed and memory usage.
+<span id="mir">MIR</span>                      &nbsp; |  The Mid-level IR that is created after type-checking for use by borrowck and codegen. ([see more](../mir/index.md))
+<span id="miri">miri</span>                    &nbsp; |  An interpreter for MIR used for constant evaluation. ([see more](../miri.md))
+<span id="mono">monomorphization</span>        &nbsp; |  The process of taking generic implementations of types and functions and instantiating them with concrete types. For example, in the code we might have `Vec<T>`, but in the final executable, we will have a copy of the `Vec` code for every concrete type used in the program (e.g. a copy for `Vec<usize>`, a copy for `Vec<MyStruct>`, etc).
+<span id="normalize">normalize</span>          &nbsp; |  A general term for converting to a more canonical form, but in the case of rustc typically refers to [associated type normalization](../traits/goals-and-clauses.md#normalizeprojection---type).
+<span id="newtype">newtype</span>              &nbsp; |  A wrapper around some other type (e.g., `struct Foo(T)` is a "newtype" for `T`). This is commonly used in Rust to give a stronger type for indices.
+<span id="niche">niche</span>                  &nbsp; |  Invalid bit patterns for a type *that can be used* for layout optimizations. Some types cannot have certain bit patterns. For example, the `NonZero*` integers or the reference `&T` cannot be represented by a 0 bitstring. This means the compiler can perform layout optimizations by taking advantage of the invalid "niche value". An example application for this is the [*Discriminant elision on `Option`-like enums*](https://rust-lang.github.io/unsafe-code-guidelines/layout/enums.html#discriminant-elision-on-option-like-enums), which allows using a type's niche as the ["tag"](#tag) for an `enum` without requiring a separate field.
+<span id="nll">NLL</span>                      &nbsp; |  Short for [non-lexical lifetimes](../borrow_check/region_inference.md), this is an extension to Rust's borrowing system to make it be based on the control-flow graph.
+<span id="node-id">node-id or NodeId</span>    &nbsp; |  An index identifying a particular node in the AST or HIR; gradually being phased out and replaced with `HirId`. See [the HIR chapter for more](../hir.md#identifiers-in-the-hir).
+<span id="obligation">obligation</span>        &nbsp; |  Something that must be proven by the trait system. ([see more](../traits/resolution.md))
+<span id="placeholder">placeholder</span>      &nbsp; |  **NOTE: skolemization is deprecated by placeholder** a way of handling subtyping around "for-all" types (e.g., `for<'a> fn(&'a u32)`) as well as solving higher-ranked trait bounds (e.g., `for<'a> T: Trait<'a>`). See [the chapter on placeholder and universes](../borrow_check/region_inference/placeholders_and_universes.md) for more details.
+<span id="point">point</span>                  &nbsp; |  Used in the NLL analysis to refer to some particular location in the MIR; typically used to refer to a node in the control-flow graph.
+<span id="polymorphize">polymorphize</span>    &nbsp; |  An optimization that avoids unnecessary monomorphisation. ([see more](../backend/monomorph.md#polymorphization))
+<span id="projection">projection</span>        &nbsp; |  A general term for a "relative path", e.g. `x.f` is a "field projection", and `T::Item` is an ["associated type projection"](../traits/goals-and-clauses.md#trait-ref).
+<span id="pc">promoted constants</span>        &nbsp; |  Constants extracted from a function and lifted to static scope; see [this section](../mir/index.md#promoted) for more details.
+<span id="provider">provider</span>            &nbsp; |  The function that executes a query. ([see more](../query.md))
+<span id="quantified">quantified</span>        &nbsp; |  In math or logic, existential and universal quantification are used to ask questions like "is there any type T for which is true?" or "is this true for all types T?"; see [the background chapter for more](./background.md#quantified).
+<span id="query">query</span>                  &nbsp; |  A sub-computation during compilation. Query results can be cached in the current session or to disk for incremental compilation. ([see more](../query.md))
+<span id="recovery">recovery</span>            &nbsp; |  Recovery refers to handling invalid syntax during parsing (e.g. a missing comma) and continuing to parse the AST. This avoid showing spurious errors to the user (e.g. showing 'missing field' errors when the struct definition contains errors).
+<span id="region">region</span>                &nbsp; |  Another term for "lifetime" often used in the literature and in the borrow checker.
+<span id="rib">rib</span>                      &nbsp; |  A data structure in the name resolver that keeps track of a single scope for names. ([see more](../name-resolution.md))
+<span id="scrutinee">scrutinee</div>           &nbsp; |  A scrutinee is the expression that is matched on in `match` expressions and similar pattern matching constructs. For example, in `match x { A => 1, B => 2 }`, the expression `x` is the scrutinee.
+<span id="sess">sess</span>                    &nbsp; |  The compiler session, which stores global data used throughout compilation
+<span id="side-tables">side tables</span>      &nbsp; |  Because the AST and HIR are immutable once created, we often carry extra information about them in the form of hashtables, indexed by the id of a particular node.
+<span id="sigil">sigil</span>                  &nbsp; |  Like a keyword but composed entirely of non-alphanumeric tokens. For example, `&` is a sigil for references.
+<span id="soundness">soundness</span>          &nbsp; |  A technical term in type theory. Roughly, if a type system is sound, then a program that type-checks is type-safe. That is, one can never (in safe rust) force a value into a variable of the wrong type. (see "completeness").
+<span id="span">span</span>                    &nbsp; |  A location in the user's source code, used for error reporting primarily. These are like a file-name/line-number/column tuple on steroids: they carry a start/end point, and also track macro expansions and compiler desugaring. All while being packed into a few bytes (really, it's an index into a table). See the [`Span`] datatype for more.
+<span id="substs">substs</span>                &nbsp; |  The substitutions for a given generic type or item (e.g. the `i32`, `u32` in `HashMap<i32, u32>`).
+<span id="sysroot">sysroot</span>              &nbsp; |  The directory for build artifacts that are loaded by the compiler at runtime. ([see more](../building/bootstrapping.html#what-is-a-sysroot))
+<span id="tag">tag</span>                      &nbsp; |  The "tag" of an enum/generator encodes the [discriminant](#discriminant) of the active variant/state.  Tags can either be "direct" (simply storing the discriminant in a field) or use a ["niche"](#niche).
+<span id="tcx">`tcx`</span>                    &nbsp; |  Standard variable name for the "typing context" (`TyCtxt`), main data structure of the compiler. ([see more](../ty.md))
+<span id="lifetime-tcx">`'tcx`</span>          &nbsp; |  The lifetime of the allocation arenas used by `TyCtxt`. Most data interned during a compilation session will use this lifetime with the exception of HIR data which uses the `'hir` lifetime. ([see more](../ty.md))
+<span id="token">token</span>                  &nbsp; |  The smallest unit of parsing. Tokens are produced after lexing ([see more](../the-parser.md)).
+<span id="tls">[TLS]</span>                    &nbsp; |  Thread-Local Storage. Variables may be defined so that each thread has its own copy (rather than all threads sharing the variable). This has some interactions with LLVM. Not all platforms support TLS.
+<span id="trait-ref">trait reference</span>    &nbsp; |  The name of a trait along with a suitable set of input type/lifetimes. ([see more](../traits/goals-and-clauses.md#trait-ref))
+<span id="trans">trans</span>                  &nbsp; |  Short for "translation", the code to translate MIR into LLVM IR. Renamed to codegen.
+<span id="ty">`Ty`</span>                      &nbsp; |  The internal representation of a type. ([see more](../ty.md))
+<span id="tyctxt">`TyCtxt`</span>              &nbsp; |  The data structure often referred to as [`tcx`](#tcx) in code which provides access to session data and the query system.
+<span id="ufcs">UFCS</span>                    &nbsp; |  Short for Universal Function Call Syntax, this is an unambiguous syntax for calling a method. ([see more](../type-checking.md))
+<span id="ut">uninhabited type</span>          &nbsp; |  A type which has _no_ values. This is not the same as a ZST, which has exactly 1 value. An example of an uninhabited type is `enum Foo {}`, which has no variants, and so, can never be created. The compiler can treat code that deals with uninhabited types as dead code, since there is no such value to be manipulated. `!` (the never type) is an uninhabited type. Uninhabited types are also called "empty types".
+<span id="upvar">upvar</span>                  &nbsp; |  A variable captured by a closure from outside the closure.
+<span id="variance">variance</span>            &nbsp; |  Determines how changes to a generic type/lifetime parameter affect subtyping; for example, if `T` is a subtype of `U`, then `Vec<T>` is a subtype `Vec<U>` because `Vec` is *covariant* in its generic parameter. See [the background chapter](./background.md#variance) for a more general explanation. See the [variance chapter](../variance.md) for an explanation of how type checking handles variance.
+<span id="variant-idx">variant index</span>    &nbsp; |  In an enum, identifies a variant by assigning them indices starting at 0.  This is purely internal and not to be confused with the ["discriminant"](#discriminant) which can be overwritten by the user (e.g. `enum Bool { True = 42, False = 0 }`).
+<span id="wide-ptr">wide pointer</span>        &nbsp; |  A pointer with additional metadata. See "fat pointer" for more.
+<span id="zst">ZST</span>                      &nbsp; |  Zero-Sized Type. A type whose values have size 0 bytes. Since `2^0 = 1`, such types can have exactly one value. For example, `()` (unit) is a ZST. `struct Foo;` is also a ZST. The compiler can do some nice optimizations around ZSTs.
+
+[LLVM]: https://llvm.org/
+[lto]: https://llvm.org/docs/LinkTimeOptimization.html
+[`Span`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html
+[thinlto]: https://clang.llvm.org/docs/ThinLTO.html
+[TLS]: https://llvm.org/docs/LangRef.html#thread-local-storage-models
diff --git a/src/doc/rustc-dev-guide/src/appendix/humorust.md b/src/doc/rustc-dev-guide/src/appendix/humorust.md
new file mode 100644
index 000000000..bc8255439
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/appendix/humorust.md
@@ -0,0 +1,15 @@
+# Humor in Rust
+
+What's a project without a sense of humor? And frankly some of these are
+enlightening?
+
+- [Weird exprs test](https://github.com/rust-lang/rust/blob/master/src/test/ui/weird-exprs.rs)
+- [Ferris Rap](http://fitzgeraldnick.com/2018/12/13/rust-raps.html)
+- [The Genesis of Generic Germination](https://github.com/rust-lang/rust/pull/53645#issue-210543221)
+- [The Bastion of the Turbofish test](https://github.com/rust-lang/rust/blob/79d8a0fcefa5134db2a94739b1d18daa01fc6e9f/src/test/ui/bastion-of-the-turbofish.rs)
+- [Rust Koans](https://users.rust-lang.org/t/rust-koans/2408)
+- [`break rust;`](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=0ab2bd6a9d722e0f05a95e2a5dcf89cc)
+- [The Nomicon Intro](https://doc.rust-lang.org/stable/nomicon/)
+- [`rustc-ty` renaming punfest](https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/rustc-ty.20naming.20bikeshed.20.2F.20punfest.20%28was.3A.20design.20meeting.202.2E.2E.2E/near/189906455)
+- [try using their name "ferris" instead](https://github.com/rust-lang/rust/pull/91476)
+- [Forbid pineapple on pizza](https://github.com/rust-lang/rust/pull/70645)
diff --git a/src/doc/rustc-dev-guide/src/asm.md b/src/doc/rustc-dev-guide/src/asm.md
new file mode 100644
index 000000000..cd5430ffd
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/asm.md
@@ -0,0 +1,367 @@
+# Inline assembly
+
+<!-- toc -->
+
+## Overview
+
+Inline assembly in rustc mostly revolves around taking an `asm!` macro invocation and plumbing it
+through all of the compiler layers down to LLVM codegen. Throughout the various stages, an
+`InlineAsm` generally consists of 3 components:
+
+- The template string, which is stored as an array of `InlineAsmTemplatePiece`. Each piece
+represents either a literal or a placeholder for an operand (just like format strings).
+```rust
+pub enum InlineAsmTemplatePiece {
+    String(String),
+    Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
+}
+```
+
+- The list of operands to the `asm!` (`in`, `[late]out`, `in[late]out`, `sym`, `const`). These are
+represented differently at each stage of lowering, but follow a common pattern:
+  - `in`, `out` and `inout` all have an associated register class (`reg`) or explicit register
+(`"eax"`).
+  - `inout` has 2 forms: one with a single expression that is both read from and written to, and
+one with two separate expressions for the input and output parts.
+  - `out` and `inout` have a `late` flag (`lateout` / `inlateout`) to indicate that the register
+allocator is allowed to reuse an input register for this output.
+  - `out` and the split variant of `inout` allow `_` to be specified for an output, which means
+that the output is discarded. This is used to allocate scratch registers for assembly code.
+  - `const` refers to an anonymous constants and generally works like an inline const.
+  - `sym` is a bit special since it only accepts a path expression, which must point to a `static`
+or a `fn`.
+
+- The options set at the end of the `asm!` macro. The only ones that are of particular interest to
+rustc are `NORETURN` which makes `asm!` return `!` instead of `()`, and `RAW` which disables format
+string parsing. The remaining options are mostly passed through to LLVM with little processing.
+```rust
+bitflags::bitflags! {
+    pub struct InlineAsmOptions: u16 {
+        const PURE = 1 << 0;
+        const NOMEM = 1 << 1;
+        const READONLY = 1 << 2;
+        const PRESERVES_FLAGS = 1 << 3;
+        const NORETURN = 1 << 4;
+        const NOSTACK = 1 << 5;
+        const ATT_SYNTAX = 1 << 6;
+        const RAW = 1 << 7;
+        const MAY_UNWIND = 1 << 8;
+    }
+}
+```
+
+## AST
+
+`InlineAsm` is represented as an expression in the AST:
+
+```rust
+pub struct InlineAsm {
+    pub template: Vec<InlineAsmTemplatePiece>,
+    pub template_strs: Box<[(Symbol, Option<Symbol>, Span)]>,
+    pub operands: Vec<(InlineAsmOperand, Span)>,
+    pub clobber_abi: Option<(Symbol, Span)>,
+    pub options: InlineAsmOptions,
+    pub line_spans: Vec<Span>,
+}
+
+pub enum InlineAsmRegOrRegClass {
+    Reg(Symbol),
+    RegClass(Symbol),
+}
+
+pub enum InlineAsmOperand {
+    In {
+        reg: InlineAsmRegOrRegClass,
+        expr: P<Expr>,
+    },
+    Out {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: Option<P<Expr>>,
+    },
+    InOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: P<Expr>,
+    },
+    SplitInOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        in_expr: P<Expr>,
+        out_expr: Option<P<Expr>>,
+    },
+    Const {
+        anon_const: AnonConst,
+    },
+    Sym {
+        expr: P<Expr>,
+    },
+}
+```
+
+The `asm!` macro is implemented in `rustc_builtin_macros` and outputs an `InlineAsm` AST node. The
+template string is parsed using `fmt_macros`, positional and named operands are resolved to
+explicit operand indices. Since target information is not available to macro invocations,
+validation of the registers and register classes is deferred to AST lowering.
+
+## HIR
+
+`InlineAsm` is represented as an expression in the HIR:
+
+```rust
+pub struct InlineAsm<'hir> {
+    pub template: &'hir [InlineAsmTemplatePiece],
+    pub template_strs: &'hir [(Symbol, Option<Symbol>, Span)],
+    pub operands: &'hir [(InlineAsmOperand<'hir>, Span)],
+    pub options: InlineAsmOptions,
+    pub line_spans: &'hir [Span],
+}
+
+pub enum InlineAsmRegOrRegClass {
+    Reg(InlineAsmReg),
+    RegClass(InlineAsmRegClass),
+}
+
+pub enum InlineAsmOperand<'hir> {
+    In {
+        reg: InlineAsmRegOrRegClass,
+        expr: Expr<'hir>,
+    },
+    Out {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: Option<Expr<'hir>>,
+    },
+    InOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: Expr<'hir>,
+    },
+    SplitInOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        in_expr: Expr<'hir>,
+        out_expr: Option<Expr<'hir>>,
+    },
+    Const {
+        anon_const: AnonConst,
+    },
+    Sym {
+        expr: Expr<'hir>,
+    },
+}
+```
+
+AST lowering is where `InlineAsmRegOrRegClass` is converted from `Symbol`s to an actual register or
+register class. If any modifiers are specified for a template string placeholder, these are
+validated against the set allowed for that operand type. Finally, explicit registers for inputs and
+outputs are checked for conflicts (same register used for different operands).
+
+## Type checking
+
+Each register class has a whitelist of types that it may be used with. After the types of all
+operands have been determined, the `intrinsicck` pass will check that these types are in the
+whitelist. It also checks that split `inout` operands have compatible types and that `const`
+operands are integers or floats. Suggestions are emitted where needed if a template modifier should
+be used for an operand based on the type that was passed into it.
+
+## THIR
+
+`InlineAsm` is represented as an expression in the THIR:
+
+```rust
+crate enum ExprKind<'tcx> {
+    // [..]
+    InlineAsm {
+        template: &'tcx [InlineAsmTemplatePiece],
+        operands: Box<[InlineAsmOperand<'tcx>]>,
+        options: InlineAsmOptions,
+        line_spans: &'tcx [Span],
+    },
+}
+crate enum InlineAsmOperand<'tcx> {
+    In {
+        reg: InlineAsmRegOrRegClass,
+        expr: ExprId,
+    },
+    Out {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: Option<ExprId>,
+    },
+    InOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        expr: ExprId,
+    },
+    SplitInOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        in_expr: ExprId,
+        out_expr: Option<ExprId>,
+    },
+    Const {
+        value: &'tcx Const<'tcx>,
+        span: Span,
+    },
+    SymFn {
+        expr: ExprId,
+    },
+    SymStatic {
+        def_id: DefId,
+    },
+}
+```
+
+The only significant change compared to HIR is that `Sym` has been lowered to either a `SymFn`
+whose `expr` is a `Literal` ZST of the `fn`, or a `SymStatic` which points to the `DefId` of a
+`static`.
+
+## MIR
+
+`InlineAsm` is represented as a `Terminator` in the MIR:
+
+```rust
+pub enum TerminatorKind<'tcx> {
+    // [..]
+
+    /// Block ends with an inline assembly block. This is a terminator since
+    /// inline assembly is allowed to diverge.
+    InlineAsm {
+        /// The template for the inline assembly, with placeholders.
+        template: &'tcx [InlineAsmTemplatePiece],
+
+        /// The operands for the inline assembly, as `Operand`s or `Place`s.
+        operands: Vec<InlineAsmOperand<'tcx>>,
+
+        /// Miscellaneous options for the inline assembly.
+        options: InlineAsmOptions,
+
+        /// Source spans for each line of the inline assembly code. These are
+        /// used to map assembler errors back to the line in the source code.
+        line_spans: &'tcx [Span],
+
+        /// Destination block after the inline assembly returns, unless it is
+        /// diverging (InlineAsmOptions::NORETURN).
+        destination: Option<BasicBlock>,
+    },
+}
+
+pub enum InlineAsmOperand<'tcx> {
+    In {
+        reg: InlineAsmRegOrRegClass,
+        value: Operand<'tcx>,
+    },
+    Out {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        place: Option<Place<'tcx>>,
+    },
+    InOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        in_value: Operand<'tcx>,
+        out_place: Option<Place<'tcx>>,
+    },
+    Const {
+        value: Box<Constant<'tcx>>,
+    },
+    SymFn {
+        value: Box<Constant<'tcx>>,
+    },
+    SymStatic {
+        def_id: DefId,
+    },
+}
+```
+
+As part of HAIR lowering, `InOut` and `SplitInOut` operands are lowered to a split form with a
+separate `in_value` and `out_place`.
+
+Semantically, the `InlineAsm` terminator is similar to the `Call` terminator except that it has
+multiple output places where a `Call` only has a single return place output.
+
+## Codegen
+
+Operands are lowered one more time before being passed to LLVM codegen:
+
+```rust
+pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
+    In {
+        reg: InlineAsmRegOrRegClass,
+        value: OperandRef<'tcx, B::Value>,
+    },
+    Out {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        place: Option<PlaceRef<'tcx, B::Value>>,
+    },
+    InOut {
+        reg: InlineAsmRegOrRegClass,
+        late: bool,
+        in_value: OperandRef<'tcx, B::Value>,
+        out_place: Option<PlaceRef<'tcx, B::Value>>,
+    },
+    Const {
+        string: String,
+    },
+    SymFn {
+        instance: Instance<'tcx>,
+    },
+    SymStatic {
+        def_id: DefId,
+    },
+}
+```
+
+The operands are lowered to LLVM operands and constraint codes as follow:
+- `out` and the output part of `inout` operands are added first, as required by LLVM. Late output
+operands have a `=` prefix added to their constraint code, non-late output operands have a `=&`
+prefix added to their constraint code.
+- `in` operands are added normally.
+- `inout` operands are tied to the matching output operand.
+- `sym` operands are passed as function pointers or pointers, using the `"s"` constraint.
+- `const` operands are formatted to a string and directly inserted in the template string.
+
+The template string is converted to LLVM form:
+- `$` characters are escaped as `$$`.
+- `const` operands are converted to strings and inserted directly.
+- Placeholders are formatted as `${X:M}` where `X` is the operand index and `M` is the modifier
+character. Modifiers are converted from the Rust form to the LLVM form.
+
+The various options are converted to clobber constraints or LLVM attributes, refer to the
+[RFC](https://github.com/Amanieu/rfcs/blob/inline-asm/text/0000-inline-asm.md#mapping-to-llvm-ir)
+for more details.
+
+Note that LLVM is sometimes rather picky about what types it accepts for certain constraint codes
+so we sometimes need to insert conversions to/from a supported type. See the target-specific
+ISelLowering.cpp files in LLVM for details of what types are supported for each register class.
+
+## Adding support for new architectures
+
+Adding inline assembly support to an architecture is mostly a matter of defining the registers and
+register classes for that architecture. All the definitions for register classes are located in
+`compiler/rustc_target/asm/`.
+
+Additionally you will need to implement lowering of these register classes to LLVM constraint codes
+in `compiler/rustc_codegen_llvm/asm.rs`.
+
+When adding a new architecture, make sure to cross-reference with the LLVM source code:
+- LLVM has restrictions on which types can be used with a particular constraint code. Refer to the
+`getRegForInlineAsmConstraint` function in `lib/Target/${ARCH}/${ARCH}ISelLowering.cpp`.
+- LLVM reserves certain registers for its internal use, which causes them to not be saved/restored
+properly around inline assembly blocks. These registers are listed in the `getReservedRegs`
+function in `lib/Target/${ARCH}/${ARCH}RegisterInfo.cpp`. Any "conditionally" reserved register
+such as the frame/base pointer must always be treated as reserved for Rust purposes because we
+can't know ahead of time whether a function will require a frame/base pointer.
+
+## Tests
+
+Various tests for inline assembly are available:
+
+- `src/test/assembly/asm`
+- `src/test/ui/asm`
+- `src/test/codegen/asm-*`
+
+Every architecture supported by inline assembly must have exhaustive tests in
+`src/test/assembly/asm` which test all combinations of register classes and types.
diff --git a/src/doc/rustc-dev-guide/src/ast-validation.md b/src/doc/rustc-dev-guide/src/ast-validation.md
new file mode 100644
index 000000000..ff549ca62
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/ast-validation.md
@@ -0,0 +1,6 @@
+# AST Validation
+
+AST validation is the process of checking various correctness properties about
+the AST after macro expansion.
+
+**TODO**: write this chapter. [#656](https://github.com/rust-lang/rustc-dev-guide/issues/656)
diff --git a/src/doc/rustc-dev-guide/src/backend/backend-agnostic.md b/src/doc/rustc-dev-guide/src/backend/backend-agnostic.md
new file mode 100644
index 000000000..271e6a16f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/backend-agnostic.md
@@ -0,0 +1,207 @@
+# Backend Agnostic Codegen
+
+<!-- toc -->
+
+As of <!-- date: 2021-10 --> October 2021, `rustc_codegen_ssa` provides an
+abstract interface for all backends to implement, to allow other codegen
+backends (e.g. [Cranelift]).
+
+[Cranelift]: https://github.com/bytecodealliance/wasmtime/tree/HEAD/cranelift
+
+> The following is a copy/paste of a README from the rust-lang/rust repo.
+> Please submit a PR if it needs updating.
+
+# Refactoring of `rustc_codegen_llvm`
+by Denis Merigoux, October 23rd 2018
+
+## State of the code before the refactoring
+
+All the code related to the compilation of MIR into LLVM IR was contained
+inside the `rustc_codegen_llvm` crate. Here is the breakdown of the most
+important elements:
+* the `back` folder (7,800 LOC) implements the mechanisms for creating the
+  different object files and archive through LLVM, but also the communication
+  mechanisms for parallel code generation;
+* the `debuginfo` (3,200 LOC) folder contains all code that passes debug
+  information down to LLVM;
+* the `llvm` (2,200 LOC) folder defines the FFI necessary to communicate with
+  LLVM using the C++ API;
+* the `mir` (4,300 LOC) folder implements the actual lowering from MIR to LLVM
+  IR;
+* the `base.rs` (1,300 LOC) file contains some helper functions but also the
+  high-level code that launches the code generation and distributes the work.
+* the `builder.rs` (1,200 LOC) file contains all the functions generating
+  individual LLVM IR instructions inside a basic block;
+* the `common.rs` (450 LOC) contains various helper functions and all the
+  functions generating LLVM static values;
+* the `type_.rs` (300 LOC) defines most of the type translations to LLVM IR.
+
+The goal of this refactoring is to separate inside this crate code that is
+specific to the LLVM from code that can be reused for other rustc backends. For
+instance, the `mir` folder is almost entirely backend-specific but it relies
+heavily on other parts of the crate. The separation of the code must not affect
+the logic of the code nor its performance.
+
+For these reasons, the separation process involves two transformations that
+have to be done at the same time for the resulting code to compile :
+
+1. replace all the LLVM-specific types by generics inside function signatures
+   and structure definitions;
+2. encapsulate all functions calling the LLVM FFI inside a set of traits that
+   will define the interface between backend-agnostic code and the backend.
+
+While the LLVM-specific code will be left in `rustc_codegen_llvm`, all the new
+traits and backend-agnostic code will be moved in `rustc_codegen_ssa` (name
+suggestion by @eddyb).
+
+## Generic types and structures
+
+@irinagpopa started to parametrize the types of `rustc_codegen_llvm` by a
+generic `Value` type, implemented in LLVM by a reference `&'ll Value`. This
+work has been extended to all structures inside the `mir` folder and elsewhere,
+as well as for LLVM's `BasicBlock` and `Type` types.
+
+The two most important structures for the LLVM codegen are `CodegenCx` and
+`Builder`. They are parametrized by multiple lifetime parameters and the type
+for `Value`.
+
+```rust,ignore
+struct CodegenCx<'ll, 'tcx> {
+  /* ... */
+}
+
+struct Builder<'a, 'll, 'tcx> {
+  cx: &'a CodegenCx<'ll, 'tcx>,
+  /* ... */
+}
+```
+
+`CodegenCx` is used to compile one codegen-unit that can contain multiple
+functions, whereas `Builder` is created to compile one basic block.
+
+The code in `rustc_codegen_llvm` has to deal with multiple explicit lifetime
+parameters, that correspond to the following:
+* `'tcx` is the longest lifetime, that corresponds to the original `TyCtxt`
+  containing the program's information;
+* `'a` is a short-lived reference of a `CodegenCx` or another object inside a
+  struct;
+* `'ll` is the lifetime of references to LLVM objects such as `Value` or
+  `Type`.
+
+Although there are already many lifetime parameters in the code, making it
+generic uncovered situations where the borrow-checker was passing only due to
+the special nature of the LLVM objects manipulated (they are extern pointers).
+For instance, an additional lifetime parameter had to be added to
+`LocalAnalyser` in `analyse.rs`, leading to the definition:
+
+```rust,ignore
+struct LocalAnalyzer<'mir, 'a, 'tcx> {
+  /* ... */
+}
+```
+
+However, the two most important structures `CodegenCx` and `Builder` are not
+defined in the backend-agnostic code. Indeed, their content is highly specific
+of the backend and it makes more sense to leave their definition to the backend
+implementor than to allow just a narrow spot via a generic field for the
+backend's context.
+
+## Traits and interface
+
+Because they have to be defined by the backend, `CodegenCx` and `Builder` will
+be the structures implementing all the traits defining the backend's interface.
+These traits are defined in the folder `rustc_codegen_ssa/traits` and all the
+backend-agnostic code is parametrized by them. For instance, let us explain how
+a function in `base.rs` is parametrized:
+
+```rust,ignore
+pub fn codegen_instance<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
+    cx: &'a Bx::CodegenCx,
+    instance: Instance<'tcx>
+) {
+    /* ... */
+}
+```
+
+In this signature, we have the two lifetime parameters explained earlier and
+the master type `Bx` which satisfies the trait `BuilderMethods` corresponding
+to the interface satisfied by the `Builder` struct. The `BuilderMethods`
+defines an associated type `Bx::CodegenCx` that itself satisfies the
+`CodegenMethods` traits implemented by the struct `CodegenCx`.
+
+On the trait side, here is an example with part of the definition of
+`BuilderMethods` in `traits/builder.rs`:
+
+```rust,ignore
+pub trait BuilderMethods<'a, 'tcx>:
+    HasCodegen<'tcx>
+    + DebugInfoBuilderMethods<'tcx>
+    + ArgTypeMethods<'tcx>
+    + AbiBuilderMethods<'tcx>
+    + IntrinsicCallMethods<'tcx>
+    + AsmBuilderMethods<'tcx>
+{
+    fn new_block<'b>(
+        cx: &'a Self::CodegenCx,
+        llfn: Self::Function,
+        name: &'b str
+    ) -> Self;
+    /* ... */
+    fn cond_br(
+        &mut self,
+        cond: Self::Value,
+        then_llbb: Self::BasicBlock,
+        else_llbb: Self::BasicBlock,
+    );
+    /* ... */
+}
+```
+
+Finally, a master structure implementing the `ExtraBackendMethods` trait is
+used for high-level codegen-driving functions like `codegen_crate` in
+`base.rs`. For LLVM, it is the empty `LlvmCodegenBackend`.
+`ExtraBackendMethods` should be implemented by the same structure that
+implements the `CodegenBackend` defined in
+`rustc_codegen_utils/codegen_backend.rs`.
+
+During the traitification process, certain functions have been converted from
+methods of a local structure to methods of `CodegenCx` or `Builder` and a
+corresponding `self` parameter has been added. Indeed, LLVM stores information
+internally that it can access when called through its API. This information
+does not show up in a Rust data structure carried around when these methods are
+called. However, when implementing a Rust backend for `rustc`, these methods
+will need information from `CodegenCx`, hence the additional parameter (unused
+in the LLVM implementation of the trait).
+
+## State of the code after the refactoring
+
+The traits offer an API which is very similar to the API of LLVM. This is not
+the best solution since LLVM has a very special way of doing things: when
+adding another backend, the traits definition might be changed in order to
+offer more flexibility.
+
+However, the current separation between backend-agnostic and LLVM-specific code
+has allowed the reuse of a significant part of the old `rustc_codegen_llvm`.
+Here is the new LOC breakdown between backend-agnostic (BA) and LLVM for the
+most important elements:
+
+* `back` folder: 3,800 (BA) vs 4,100 (LLVM);
+* `mir` folder: 4,400 (BA) vs 0 (LLVM);
+* `base.rs`: 1,100 (BA) vs 250 (LLVM);
+* `builder.rs`: 1,400 (BA) vs 0 (LLVM);
+* `common.rs`: 350 (BA) vs 350 (LLVM);
+
+The `debuginfo` folder has been left almost untouched by the splitting and is
+specific to LLVM. Only its high-level features have been traitified.
+
+The new `traits` folder has 1500 LOC only for trait definitions. Overall, the
+27,000 LOC-sized old `rustc_codegen_llvm` code has been split into the new
+18,500 LOC-sized new `rustc_codegen_llvm` and the 12,000 LOC-sized
+`rustc_codegen_ssa`. We can say that this refactoring allowed the reuse of
+approximately 10,000 LOC that would otherwise have had to be duplicated between
+the multiple backends of `rustc`.
+
+The refactored version of `rustc`'s backend introduced no regression over the
+test suite nor in performance benchmark, which is in coherence with the nature
+of the refactoring that used only compile-time parametricity (no trait
+objects).
diff --git a/src/doc/rustc-dev-guide/src/backend/codegen.md b/src/doc/rustc-dev-guide/src/backend/codegen.md
new file mode 100644
index 000000000..1a6c2fa76
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/codegen.md
@@ -0,0 +1,76 @@
+# Code generation
+
+Code generation or "codegen" is the part of the compiler that actually
+generates an executable binary. Usually, rustc uses LLVM for code generation;
+there is also support for [Cranelift]. The key is that rustc doesn't implement
+codegen itself. It's worth noting, though, that in the Rust source code, many
+parts of the backend have `codegen` in their names (there are no hard
+boundaries).
+
+[Cranelift]: https://github.com/bytecodealliance/wasmtime/tree/HEAD/cranelift
+
+> NOTE: If you are looking for hints on how to debug code generation bugs,
+> please see [this section of the debugging chapter][debugging].
+
+[debugging]: ./debugging.md
+
+## What is LLVM?
+
+[LLVM](https://llvm.org) is "a collection of modular and reusable compiler and
+toolchain technologies". In particular, the LLVM project contains a pluggable
+compiler backend (also called "LLVM"), which is used by many compiler projects,
+including the `clang` C compiler and our beloved `rustc`.
+
+LLVM takes input in the form of LLVM IR. It is basically assembly code with
+additional low-level types and annotations added. These annotations are helpful
+for doing optimizations on the LLVM IR and outputted machine code. The end
+result of all this is (at long last) something executable (e.g. an ELF object,
+an EXE, or wasm).
+
+There are a few benefits to using LLVM:
+
+- We don't have to write a whole compiler backend. This reduces implementation
+  and maintenance burden.
+- We benefit from the large suite of advanced optimizations that the LLVM
+  project has been collecting.
+- We can automatically compile Rust to any of the platforms for which LLVM has
+  support. For example, as soon as LLVM added support for wasm, voila! rustc,
+  clang, and a bunch of other languages were able to compile to wasm! (Well,
+  there was some extra stuff to be done, but we were 90% there anyway).
+- We and other compiler projects benefit from each other. For example, when the
+  [Spectre and Meltdown security vulnerabilities][spectre] were discovered,
+  only LLVM needed to be patched.
+
+[spectre]: https://meltdownattack.com/
+
+## Running LLVM, linking, and metadata generation
+
+Once LLVM IR for all of the functions and statics, etc is built, it is time to
+start running LLVM and its optimization passes. LLVM IR is grouped into
+"modules". Multiple "modules" can be codegened at the same time to aid in
+multi-core utilization. These "modules" are what we refer to as _codegen
+units_. These units were established way back during monomorphization
+collection phase.
+
+Once LLVM produces objects from these modules, these objects are passed to the
+linker along with, optionally, the metadata object and an archive or an
+executable is produced.
+
+It is not necessarily the codegen phase described above that runs the
+optimizations. With certain kinds of LTO, the optimization might happen at the
+linking time instead. It is also possible for some optimizations to happen
+before objects are passed on to the linker and some to happen during the
+linking.
+
+This all happens towards the very end of compilation. The code for this can be
+found in [`rustc_codegen_ssa::back`][ssaback] and
+[`rustc_codegen_llvm::back`][llvmback]. Sadly, this piece of code is not
+really well-separated into LLVM-dependent code; the [`rustc_codegen_ssa`][ssa]
+contains a fair amount of code specific to the LLVM backend.
+
+Once these components are done with their work you end up with a number of
+files in your filesystem corresponding to the outputs you have requested.
+
+[ssa]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/index.html
+[ssaback]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/back/index.html
+[llvmback]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/back/index.html
diff --git a/src/doc/rustc-dev-guide/src/backend/debugging.md b/src/doc/rustc-dev-guide/src/backend/debugging.md
new file mode 100644
index 000000000..791a61fbe
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/debugging.md
@@ -0,0 +1,258 @@
+## Debugging LLVM
+
+> NOTE: If you are looking for info about code generation, please see [this
+> chapter][codegen] instead.
+
+[codegen]: ./codegen.md
+
+This section is about debugging compiler bugs in code generation (e.g. why the
+compiler generated some piece of code or crashed in LLVM).  LLVM is a big
+project on its own that probably needs to have its own debugging document (not
+that I could find one). But here are some tips that are important in a rustc
+context:
+
+### Minimize the example
+
+As a general rule, compilers generate lots of information from analyzing code.
+Thus, a useful first step is usually to find a minimal example. One way to do
+this is to
+
+1. create a new crate that reproduces the issue (e.g. adding whatever crate is
+at fault as a dependency, and using it from there)
+
+2. minimize the crate by removing external dependencies; that is, moving
+everything relevant to the new crate
+
+3. further minimize the issue by making the code shorter (there are tools that
+help with this like `creduce`)
+
+For more discussion on methodology for steps 2 and 3 above, there is an
+[epic blog post][mcve-blog] from pnkfelix specifically about Rust program minimization.
+
+[mcve-blog]: https://blog.pnkfx.org/blog/2019/11/18/rust-bug-minimization-patterns/
+
+### Enable LLVM internal checks
+
+The official compilers (including nightlies) have LLVM assertions disabled,
+which means that LLVM assertion failures can show up as compiler crashes (not
+ICEs but "real" crashes) and other sorts of weird behavior. If you are
+encountering these, it is a good idea to try using a compiler with LLVM
+assertions enabled - either an "alt" nightly or a compiler you build yourself
+by setting `[llvm] assertions=true` in your config.toml - and see whether
+anything turns up.
+
+The rustc build process builds the LLVM tools into
+`./build/<host-triple>/llvm/bin`. They can be called directly.
+These tools include:
+ * [`llc`], which compiles bitcode (`.bc` files) to executable code; this can be used to
+   replicate LLVM backend bugs.
+ * [`opt`], a bitcode transformer that runs LLVM optimization passes.
+ * [`bugpoint`], which reduces large test cases to small, useful ones.
+ * and many others, some of which are referenced in the text below.
+
+[`llc`]: https://llvm.org/docs/CommandGuide/llc.html
+[`opt`]: https://llvm.org/docs/CommandGuide/opt.html
+[`bugpoint`]: https://llvm.org/docs/Bugpoint.html
+
+By default, the Rust build system does not check for changes to the LLVM source code or
+its build configuration settings. So, if you need to rebuild the LLVM that is linked
+into `rustc`, first delete the file `llvm-finished-building`, which should be located
+in `build/<host-triple>/llvm/`.
+
+The default rustc compilation pipeline has multiple codegen units, which is
+hard to replicate manually and means that LLVM is called multiple times in
+parallel.  If you can get away with it (i.e. if it doesn't make your bug
+disappear), passing `-C codegen-units=1` to rustc will make debugging easier.
+
+### Get your hands on raw LLVM input
+
+For rustc to generate LLVM IR, you need to pass the `--emit=llvm-ir` flag. If
+you are building via cargo, use the `RUSTFLAGS` environment variable (e.g.
+`RUSTFLAGS='--emit=llvm-ir'`). This causes rustc to spit out LLVM IR into the
+target directory.
+
+`cargo llvm-ir [options] path` spits out the LLVM IR for a particular function
+at `path`. (`cargo install cargo-asm` installs `cargo asm` and `cargo
+llvm-ir`). `--build-type=debug` emits code for debug builds. There are also
+other useful options. Also, debug info in LLVM IR can clutter the output a lot:
+`RUSTFLAGS="-C debuginfo=0"` is really useful.
+
+`RUSTFLAGS="-C save-temps"` outputs LLVM bitcode (not the same as IR) at
+different stages during compilation, which is sometimes useful. The output LLVM
+bitcode will be in `.bc` files in the compiler's output directory, set via the
+`--out-dir DIR` argument to `rustc`.
+
+ * If you are hitting an assertion failure or segmentation fault from the LLVM
+   backend when invoking `rustc` itself, it is a good idea to try passing each
+   of these `.bc` files to the `llc` command, and see if you get the same
+   failure. (LLVM developers often prefer a bug reduced to a `.bc` file over one
+   that uses a Rust crate for its minimized reproduction.)
+
+ * To get human readable versions of the LLVM bitcode, one just needs to convert
+   the bitcode (`.bc`) files to `.ll` files using `llvm-dis`, which should be in
+   the target local compilation of rustc.
+
+
+Note that rustc emits different IR depending on whether `-O` is enabled, even
+without LLVM's optimizations, so if you want to play with the IR rustc emits,
+you should:
+
+```bash
+$ rustc +local my-file.rs --emit=llvm-ir -O -C no-prepopulate-passes \
+    -C codegen-units=1
+$ OPT=./build/$TRIPLE/llvm/bin/opt
+$ $OPT -S -O2 < my-file.ll > my
+```
+
+If you just want to get the LLVM IR during the LLVM pipeline, to e.g. see which
+IR causes an optimization-time assertion to fail, or to see when LLVM performs
+a particular optimization, you can pass the rustc flag `-C
+llvm-args=-print-after-all`, and possibly add `-C
+llvm-args='-filter-print-funcs=EXACT_FUNCTION_NAME` (e.g.  `-C
+llvm-args='-filter-print-funcs=_ZN11collections3str21_$LT$impl$u20$str$GT$\
+7replace17hbe10ea2e7c809b0bE'`).
+
+That produces a lot of output into standard error, so you'll want to pipe that
+to some file. Also, if you are using neither `-filter-print-funcs` nor `-C
+codegen-units=1`, then, because the multiple codegen units run in parallel, the
+printouts will mix together and you won't be able to read anything.
+
+ * One caveat to the aforementioned methodology: the `-print` family of options
+   to LLVM only prints the IR unit that the pass runs on (e.g., just a
+   function), and does not include any referenced declarations, globals,
+   metadata, etc. This means you cannot in general feed the output of `-print`
+   into `llc` to reproduce a given problem.
+
+ * Within LLVM itself, calling `F.getParent()->dump()` at the beginning of
+   `SafeStackLegacyPass::runOnFunction` will dump the whole module, which
+   may provide better basis for reproduction. (However, you
+   should be able to get that same dump from the `.bc` files dumped by
+   `-C save-temps`.)
+
+If you want just the IR for a specific function (say, you want to see why it
+causes an assertion or doesn't optimize correctly), you can use `llvm-extract`,
+e.g.
+
+```bash
+$ ./build/$TRIPLE/llvm/bin/llvm-extract \
+    -func='_ZN11collections3str21_$LT$impl$u20$str$GT$7replace17hbe10ea2e7c809b0bE' \
+    -S \
+    < unextracted.ll \
+    > extracted.ll
+```
+
+### Investigate LLVM optimization passes
+
+If you are seeing incorrect behavior due to an optimization pass, a very handy
+LLVM option is `-opt-bisect-limit`, which takes an integer denoting the index
+value of the highest pass to run.  Index values for taken passes are stable
+from run to run; by coupling this with software that automates bisecting the
+search space based on the resulting program, an errant pass can be quickly
+determined.  When an `-opt-bisect-limit` is specified, all runs are displayed
+to standard error, along with their index and output indicating if the
+pass was run or skipped.  Setting the limit to an index of -1 (e.g.,
+`RUSTFLAGS="-C llvm-args=-opt-bisect-limit=-1"`) will show all passes and
+their corresponding index values.
+
+If you want to play with the optimization pipeline, you can use the [`opt`] tool
+from `./build/<host-triple>/llvm/bin/` with the LLVM IR emitted by rustc.
+
+When investigating the implementation of LLVM itself, you should be
+aware of its [internal debug infrastructure][llvm-debug].
+This is provided in LLVM Debug builds, which you enable for rustc
+LLVM builds by changing this setting in the config.toml:
+```
+[llvm]
+# Indicates whether the LLVM assertions are enabled or not
+assertions = true
+
+# Indicates whether the LLVM build is a Release or Debug build
+optimize = false
+```
+The quick summary is:
+ * Setting `assertions=true` enables coarse-grain debug messaging.
+   * beyond that, setting `optimize=false` enables fine-grain debug messaging.
+ * `LLVM_DEBUG(dbgs() << msg)` in LLVM is like `debug!(msg)` in `rustc`.
+ * The `-debug` option turns on all messaging; it is like setting the
+   environment variable `RUSTC_LOG=debug` in `rustc`.
+ * The `-debug-only=<pass1>,<pass2>` variant is more selective; it is like
+   setting the environment variable `RUSTC_LOG=path1,path2` in `rustc`.
+
+[llvm-debug]: https://llvm.org/docs/ProgrammersManual.html#the-llvm-debug-macro-and-debug-option
+
+### Getting help and asking questions
+
+If you have some questions, head over to the [rust-lang Zulip] and
+specifically the `#t-compiler/wg-llvm` stream.
+
+[rust-lang Zulip]: https://rust-lang.zulipchat.com/
+
+### Compiler options to know and love
+
+The `-C help` and `-Z help` compiler switches will list out a variety
+of interesting options you may find useful. Here are a few of the most
+common that pertain to LLVM development (some of them are employed in the
+tutorial above):
+
+- The `--emit llvm-ir` option emits a `<filename>.ll` file with LLVM IR in textual format
+    - The `--emit llvm-bc` option emits in bytecode format (`<filename>.bc`)
+- Passing `-C llvm-args=<foo>` allows passing pretty much all the
+  options that tools like llc and opt would accept;
+  e.g. `-C llvm-args=-print-before-all` to print IR before every LLVM
+  pass.
+- The `-C no-prepopulate-passes` will avoid pre-populate the LLVM pass
+  manager with a list of passes.  This will allow you to view the LLVM
+  IR that rustc generates, not the LLVM IR after optimizations.
+- The `-C passes=val` option allows you to supply a space separated list of extra LLVM passes to run
+- The `-C save-temps` option saves all temporary output files during compilation
+- The `-Z print-llvm-passes` option will print out LLVM optimization passes being run
+- The `-Z time-llvm-passes` option measures the time of each LLVM pass
+- The `-Z verify-llvm-ir` option will verify the LLVM IR for correctness
+- The `-Z no-parallel-llvm` will disable parallel compilation of distinct compilation units
+- The `-Z llvm-time-trace` option will output a Chrome profiler compatible JSON file
+  which contains details and timings for LLVM passes.
+- The `-C llvm-args=-opt-bisect-limit=<index>` option allows for bisecting LLVM
+  optimizations.
+
+### Filing LLVM bug reports
+
+When filing an LLVM bug report, you will probably want some sort of minimal
+working example that demonstrates the problem. The Godbolt compiler explorer is
+really helpful for this.
+
+1. Once you have some LLVM IR for the problematic code (see above), you can
+create a minimal working example with Godbolt. Go to
+[gcc.godbolt.org](https://gcc.godbolt.org).
+
+2. Choose `LLVM-IR` as programming language.
+
+3. Use `llc` to compile the IR to a particular target as is:
+    - There are some useful flags: `-mattr` enables target features, `-march=`
+      selects the target, `-mcpu=` selects the CPU, etc.
+    - Commands like `llc -march=help` output all architectures available, which
+      is useful because sometimes the Rust arch names and the LLVM names do not
+      match.
+    - If you have compiled rustc yourself somewhere, in the target directory
+      you have binaries for `llc`, `opt`, etc.
+
+4. If you want to optimize the LLVM-IR, you can use `opt` to see how the LLVM
+   optimizations transform it.
+
+5. Once you have a godbolt link demonstrating the issue, it is pretty easy to
+   fill in an LLVM bug. Just visit their [github issues page][llvm-issues].
+
+[llvm-issues]: https://github.com/llvm/llvm-project/issues
+
+### Porting bug fixes from LLVM
+
+Once you've identified the bug as an LLVM bug, you will sometimes
+find that it has already been reported and fixed in LLVM, but we haven't
+gotten the fix yet (or perhaps you are familiar enough with LLVM to fix it yourself).
+
+In that case, we can sometimes opt to port the fix for the bug
+directly to our own LLVM fork, so that rustc can use it more easily.
+Our fork of LLVM is maintained in [rust-lang/llvm-project]. Once
+you've landed the fix there, you'll also need to land a PR modifying
+our submodule commits -- ask around on Zulip for help.
+
+[rust-lang/llvm-project]: https://github.com/rust-lang/llvm-project/
diff --git a/src/doc/rustc-dev-guide/src/backend/implicit-caller-location.md b/src/doc/rustc-dev-guide/src/backend/implicit-caller-location.md
new file mode 100644
index 000000000..21554f5a4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/implicit-caller-location.md
@@ -0,0 +1,281 @@
+# Implicit Caller Location
+
+<!-- toc -->
+
+Approved in [RFC 2091], this feature enables the accurate reporting of caller location during panics
+initiated from functions like `Option::unwrap`, `Result::expect`, and `Index::index`. This feature
+adds the [`#[track_caller]`][attr-reference] attribute for functions, the
+[`caller_location`][intrinsic] intrinsic, and the stabilization-friendly
+[`core::panic::Location::caller`][wrapper] wrapper.
+
+## Motivating Example
+
+Take this example program:
+
+```rust
+fn main() {
+    let foo: Option<()> = None;
+    foo.unwrap(); // this should produce a useful panic message!
+}
+```
+
+Prior to Rust 1.42, panics like this `unwrap()` printed a location in core:
+
+```
+$ rustc +1.41.0 example.rs; example.exe
+thread 'main' panicked at 'called `Option::unwrap()` on a `None` value',...core\macros\mod.rs:15:40
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
+```
+
+As of 1.42, we get a much more helpful message:
+
+```
+$ rustc +1.42.0 example.rs; example.exe
+thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', example.rs:3:5
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+```
+
+These error messages are achieved through a combination of changes to `panic!` internals to make use
+of `core::panic::Location::caller` and a number of `#[track_caller]` annotations in the standard
+library which propagate caller information.
+
+## Reading Caller Location
+
+Previously, `panic!` made use of the `file!()`, `line!()`, and `column!()` macros to construct a
+[`Location`] pointing to where the panic occurred. These macros couldn't be given an overridden
+location, so functions which intentionally invoked `panic!` couldn't provide their own location,
+hiding the actual source of error.
+
+Internally, `panic!()` now calls [`core::panic::Location::caller()`][wrapper] to find out where it
+was expanded. This function is itself annotated with `#[track_caller]` and wraps the
+[`caller_location`][intrinsic] compiler intrinsic implemented by rustc. This intrinsic is easiest
+explained in terms of how it works in a `const` context.
+
+## Caller Location in `const`
+
+There are two main phases to returning the caller location in a const context: walking up the stack
+to find the right location and allocating a const value to return.
+
+### Finding the right `Location`
+
+In a const context we "walk up the stack" from where the intrinsic is invoked, stopping when we
+reach the first function call in the stack which does *not* have the attribute. This walk is in
+[`InterpCx::find_closest_untracked_caller_location()`][const-find-closest].
+
+Starting at the bottom, we iterate up over stack [`Frame`][const-frame]s in the
+[`InterpCx::stack`][const-stack], calling
+[`InstanceDef::requires_caller_location`][requires-location] on the
+[`Instance`s from each `Frame`][frame-instance]. We stop once we find one that returns `false` and
+return the span of the *previous* frame which was the "topmost" tracked function.
+
+### Allocating a static `Location`
+
+Once we have a `Span`, we need to allocate static memory for the `Location`, which is performed by
+the [`TyCtxt::const_caller_location()`][const-location-query] query. Internally this calls
+[`InterpCx::alloc_caller_location()`][alloc-location] and results in a unique
+[memory kind][location-memory-kind] (`MemoryKind::CallerLocation`). The SSA codegen backend is able
+to emit code for these same values, and we use this code there as well.
+
+Once our `Location` has been allocated in static memory, our intrinsic returns a reference to it.
+
+## Generating code for `#[track_caller]` callees
+
+To generate efficient code for a tracked function and its callers, we need to provide the same
+behavior from the intrinsic's point of view without having a stack to walk up at runtime. We invert
+the approach: as we grow the stack down we pass an additional argument to calls of tracked functions
+rather than walking up the stack when the intrinsic is called. That additional argument can be
+returned wherever the caller location is queried.
+
+The argument we append is of type `&'static core::panic::Location<'static>`. A reference was chosen
+to avoid unnecessary copying because a pointer is a third the size of
+`std::mem::size_of::<core::panic::Location>() == 24` at time of writing.
+
+When generating a call to a function which is tracked, we pass the location argument the value of
+[`FunctionCx::get_caller_location`][fcx-get].
+
+If the calling function is tracked, `get_caller_location` returns the local in
+[`FunctionCx::caller_location`][fcx-location] which was populated by the current caller's caller.
+In these cases the intrinsic "returns" a reference which was actually provided in an argument to its
+caller.
+
+If the calling function is not tracked, `get_caller_location` allocates a `Location` static from
+the current `Span` and returns a reference to that.
+
+We more efficiently achieve the same behavior as a loop starting from the bottom by passing a single
+`&Location` value through the `caller_location` fields of multiple `FunctionCx`s as we grow the
+stack downward.
+
+### Codegen examples
+
+What does this transformation look like in practice? Take this example which uses the new feature:
+
+```rust
+#![feature(track_caller)]
+use std::panic::Location;
+
+#[track_caller]
+fn print_caller() {
+    println!("called from {}", Location::caller());
+}
+
+fn main() {
+    print_caller();
+}
+```
+
+Here `print_caller()` appears to take no arguments, but we compile it to something like this:
+
+```rust
+#![feature(panic_internals)]
+use std::panic::Location;
+
+fn print_caller(caller: &Location) {
+    println!("called from {}", caller);
+}
+
+fn main() {
+    print_caller(&Location::internal_constructor(file!(), line!(), column!()));
+}
+```
+
+### Dynamic Dispatch
+
+In codegen contexts we have to modify the callee ABI to pass this information down the stack, but
+the attribute expressly does *not* modify the type of the function. The ABI change must be
+transparent to type checking and remain sound in all uses.
+
+Direct calls to tracked functions will always know the full codegen flags for the callee and can
+generate appropriate code. Indirect callers won't have this information and it's not encoded in
+the type of the function pointer they call, so we generate a [`ReifyShim`] around the function
+whenever taking a pointer to it. This shim isn't able to report the actual location of the indirect
+call (the function's definition site is reported instead), but it prevents miscompilation and is
+probably the best we can do without modifying fully-stabilized type signatures.
+
+> *Note:* We always emit a [`ReifyShim`] when taking a pointer to a tracked function. While the
+> constraint here is imposed by codegen contexts, we don't know during MIR construction of the shim
+> whether we'll be called in a const context (safe to ignore shim) or in a codegen context (unsafe
+> to ignore shim). Even if we did know, the results from const and codegen contexts must agree.
+
+## The Attribute
+
+The `#[track_caller]` attribute is checked alongside other codegen attributes to ensure the
+function:
+
+* has the `"Rust"` ABI (as opposed to e.g., `"C"`)
+* is not a closure
+* is not `#[naked]`
+
+If the use is valid, we set [`CodegenFnAttrsFlags::TRACK_CALLER`][attrs-flags]. This flag influences
+the return value of [`InstanceDef::requires_caller_location`][requires-location] which is in turn
+used in both const and codegen contexts to ensure correct propagation.
+
+### Traits
+
+When applied to trait method implementations, the attribute works as it does for regular functions.
+
+When applied to a trait method prototype, the attribute applies to all implementations of the
+method. When applied to a default trait method implementation, the attribute takes effect on
+that implementation *and* any overrides.
+
+Examples:
+
+```rust
+#![feature(track_caller)]
+
+macro_rules! assert_tracked {
+    () => {{
+        let location = std::panic::Location::caller();
+        assert_eq!(location.file(), file!());
+        assert_ne!(location.line(), line!(), "line should be outside this fn");
+        println!("called at {}", location);
+    }};
+}
+
+trait TrackedFourWays {
+    /// All implementations inherit `#[track_caller]`.
+    #[track_caller]
+    fn blanket_tracked();
+
+    /// Implementors can annotate themselves.
+    fn local_tracked();
+
+    /// This implementation is tracked (overrides are too).
+    #[track_caller]
+    fn default_tracked() {
+        assert_tracked!();
+    }
+
+    /// Overrides of this implementation are tracked (it is too).
+    #[track_caller]
+    fn default_tracked_to_override() {
+        assert_tracked!();
+    }
+}
+
+/// This impl uses the default impl for `default_tracked` and provides its own for
+/// `default_tracked_to_override`.
+impl TrackedFourWays for () {
+    fn blanket_tracked() {
+        assert_tracked!();
+    }
+
+    #[track_caller]
+    fn local_tracked() {
+        assert_tracked!();
+    }
+
+    fn default_tracked_to_override() {
+        assert_tracked!();
+    }
+}
+
+fn main() {
+    <() as TrackedFourWays>::blanket_tracked();
+    <() as TrackedFourWays>::default_tracked();
+    <() as TrackedFourWays>::default_tracked_to_override();
+    <() as TrackedFourWays>::local_tracked();
+}
+```
+
+## Background/History
+
+Broadly speaking, this feature's goal is to improve common Rust error messages without breaking
+stability guarantees, requiring modifications to end-user source, relying on platform-specific
+debug-info, or preventing user-defined types from having the same error-reporting benefits.
+
+Improving the output of these panics has been a goal of proposals since at least mid-2016 (see
+[non-viable alternatives] in the approved RFC for details). It took two more years until RFC 2091
+was approved, much of its [rationale] for this feature's design having been discovered through the
+discussion around several earlier proposals.
+
+The design in the original RFC limited itself to implementations that could be done inside the
+compiler at the time without significant refactoring. However in the year and a half between the
+approval of the RFC and the actual implementation work, a [revised design] was proposed and written
+up on the tracking issue. During the course of implementing that, it was also discovered that an
+implementation was possible without modifying the number of arguments in a function's MIR, which
+would simplify later stages and unlock use in traits.
+
+Because the RFC's implementation strategy could not readily support traits, the semantics were not
+originally specified. They have since been implemented following the path which seemed most correct
+to the author and reviewers.
+
+[RFC 2091]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md
+[attr-reference]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-track_caller-attribute
+[intrinsic]: https://doc.rust-lang.org/nightly/core/intrinsics/fn.caller_location.html
+[wrapper]: https://doc.rust-lang.org/nightly/core/panic/struct.Location.html#method.caller
+[non-viable alternatives]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md#non-viable-alternatives
+[rationale]: https://github.com/rust-lang/rfcs/blob/master/text/2091-inline-semantic.md#rationale
+[revised design]: https://github.com/rust-lang/rust/issues/47809#issuecomment-443538059
+[attrs-flags]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/middle/codegen_fn_attrs/struct.CodegenFnAttrFlags.html#associatedconstant.TRACK_CALLER
+[`ReifyShim`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.InstanceDef.html#variant.ReifyShim
+[`Location`]: https://doc.rust-lang.org/core/panic/struct.Location.html
+[const-find-closest]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.InterpCx.html#method.find_closest_untracked_caller_location
+[requires-location]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.InstanceDef.html#method.requires_caller_location
+[alloc-location]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.InterpCx.html#method.alloc_caller_location
+[fcx-location]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/struct.FunctionCx.html#structfield.caller_location
+[const-location-query]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.const_caller_location
+[location-memory-kind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/enum.MemoryKind.html#variant.CallerLocation
+[const-frame]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.Frame.html
+[const-stack]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.InterpCx.html#structfield.stack
+[fcx-get]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/struct.FunctionCx.html#method.get_caller_location
+[frame-instance]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.Frame.html#structfield.instance
diff --git a/src/doc/rustc-dev-guide/src/backend/inline-asm.md b/src/doc/rustc-dev-guide/src/backend/inline-asm.md
new file mode 100644
index 000000000..f1a64b5ee
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/inline-asm.md
@@ -0,0 +1,5 @@
+# Inline Assembly
+
+**TODO**: You can find more info 
+[here](https://github.com/rust-lang/rust/pull/69171#issue-375572066)
+[#1162](https://github.com/rust-lang/rustc-dev-guide/issues/1162)
diff --git a/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md b/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md
new file mode 100644
index 000000000..5e005c965
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md
@@ -0,0 +1,192 @@
+# Libraries and Metadata
+
+When the compiler sees a reference to an external crate, it needs to load some
+information about that crate. This chapter gives an overview of that process,
+and the supported file formats for crate libraries.
+
+## Libraries
+
+A crate dependency can be loaded from an `rlib`, `dylib`, or `rmeta` file. A
+key point of these file formats is that they contain `rustc`-specific
+[*metadata*](#metadata). This metadata allows the compiler to discover enough
+information about the external crate to understand the items it contains,
+which macros it exports, and *much* more.
+
+### rlib
+
+An `rlib` is an [archive file], which is similar to a tar file. This file
+format is specific to `rustc`, and may change over time. This file contains:
+
+* Object code, which is the result of code generation. This is used during
+  regular linking. There is a separate `.o` file for each [codegen unit]. The
+  codegen step can be skipped with the [`-C
+  linker-plugin-lto`][linker-plugin-lto] CLI option, which means each `.o`
+  file will only contain LLVM bitcode.
+* [LLVM bitcode], which is a binary representation of LLVM's intermediate
+  representation, which is embedded as a section in the `.o` files. This can
+  be used for [Link Time Optimization] (LTO). This can be removed with the
+  [`-C embed-bitcode=no`][embed-bitcode] CLI option to improve compile times
+  and reduce disk space if LTO is not needed.
+* `rustc` [metadata], in a file named `lib.rmeta`.
+* A symbol table, which is generally a list of symbols with offsets to the
+  object file that contain that symbol. This is pretty standard for archive
+  files.
+
+[archive file]: https://en.wikipedia.org/wiki/Ar_(Unix)
+[LLVM bitcode]: https://llvm.org/docs/BitCodeFormat.html
+[Link Time Optimization]: https://llvm.org/docs/LinkTimeOptimization.html
+[codegen unit]: ../backend/codegen.md
+[embed-bitcode]: https://doc.rust-lang.org/rustc/codegen-options/index.html#embed-bitcode
+[linker-plugin-lto]: https://doc.rust-lang.org/rustc/codegen-options/index.html#linker-plugin-lto
+
+### dylib
+
+A `dylib` is a platform-specific shared library. It includes the `rustc`
+[metadata] in a special link section called `.rustc` in a compressed format.
+
+### rmeta
+
+An `rmeta` file is custom binary format that contains the [metadata] for the
+crate. This file can be used for fast "checks" of a project by skipping all
+code generation (as is done with `cargo check`), collecting enough information
+for documentation (as is done with `cargo doc`), or for
+[pipelining](#pipelining). This file is created if the
+[`--emit=metadata`][emit] CLI option is used.
+
+`rmeta` files do not support linking, since they do not contain compiled
+object files.
+
+[emit]: https://doc.rust-lang.org/rustc/command-line-arguments.html#option-emit
+
+## Metadata
+
+The metadata contains a wide swath of different elements. This guide will not
+go into detail of every field it contains. You are encouraged to browse the
+[`CrateRoot`] definition to get a sense of the different elements it contains.
+Everything about metadata encoding and decoding is in the [`rustc_metadata`]
+package.
+
+Here are a few highlights of things it contains:
+
+* The version of the `rustc` compiler. The compiler will refuse to load files
+  from any other version.
+* The [Strict Version Hash](#strict-version-hash) (SVH). This helps ensure the
+  correct dependency is loaded.
+* The [Stable Crate Id](#stable-crate-id). This is a hash used
+  to identify crates.
+* Information about all the source files in the library. This can be used for
+  a variety of things, such as diagnostics pointing to sources in a
+  dependency.
+* Information about exported macros, traits, types, and items. Generally,
+  anything that's needed to be known when a path references something inside a
+  crate dependency.
+* Encoded [MIR]. This is optional, and only encoded if needed for code
+  generation. `cargo check` skips this for performance reasons.
+
+[`CrateRoot`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/struct.CrateRoot.html
+[`rustc_metadata`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/index.html
+[MIR]: ../mir/index.md
+
+### Strict Version Hash
+
+The Strict Version Hash ([SVH], also known as the "crate hash") is a 64-bit
+hash that is used to ensure that the correct crate dependencies are loaded. It
+is possible for a directory to contain multiple copies of the same dependency
+built with different settings, or built from different sources. The crate
+loader will skip any crates that have the wrong SVH.
+
+The SVH is also used for the [incremental compilation] session filename,
+though that usage is mostly historic.
+
+The hash includes a variety of elements:
+
+* Hashes of the HIR nodes.
+* All of the upstream crate hashes.
+* All of the source filenames.
+* Hashes of certain command-line flags (like `-C metadata` via the [Crate
+  Disambiguator](#crate-disambiguator), and all CLI options marked with
+  `[TRACKED]`).
+
+See [`compute_hir_hash`] for where the hash is actually computed.
+
+[SVH]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/svh/struct.Svh.html
+[incremental compilation]: ../queries/incremental-compilation.md
+[`compute_hir_hash`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_lowering/struct.LoweringContext.html#method.compute_hir_hash
+
+### Stable Crate Id
+
+The [`StableCrateId`] is a 64-bit hash used to identify different crates with
+potentially the same name. It is a hash of the crate name and all the
+[`-C metadata`] CLI options computed in [`StableCrateId::new`]. It is
+used in a variety of places, such as symbol name mangling, crate loading, and
+much more.
+
+By default, all Rust symbols are mangled and incorporate the stable crate id.
+This allows multiple versions of the same crate to be included together. Cargo
+automatically generates `-C metadata` hashes based on a variety of factors,
+like the package version, source, and the target kind (a lib and test can have
+the same crate name, so they need to be disambiguated).
+
+[`StableCrateId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/def_id/struct.StableCrateId.html
+[`StableCrateId::new`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/def_id/struct.StableCrateId.html#method.new
+[`-C metadata`]: https://doc.rust-lang.org/rustc/codegen-options/index.html#metadata
+
+## Crate loading
+
+Crate loading can have quite a few subtle complexities. During [name
+resolution], when an external crate is referenced (via an `extern crate` or
+path), the resolver uses the [`CrateLoader`] which is responsible for finding
+the crate libraries and loading the [metadata] for them. After the dependency
+is loaded, the `CrateLoader` will provide the information the resolver needs
+to perform its job (such as expanding macros, resolving paths, etc.).
+
+To load each external crate, the `CrateLoader` uses a [`CrateLocator`] to
+actually find the correct files for one specific crate. There is some great
+documentation in the [`locator`] module that goes into detail on how loading
+works, and I strongly suggest reading it to get the full picture.
+
+The location of a dependency can come from several different places. Direct
+dependencies are usually passed with `--extern` flags, and the loader can look
+at those directly. Direct dependencies often have references to their own
+dependencies, which need to be loaded, too. These are usually found by
+scanning the directories passed with the `-L` flag for any file whose metadata
+contains a matching crate name and [SVH](#strict-version-hash). The loader
+will also look at the [sysroot] to find dependencies.
+
+As crates are loaded, they are kept in the [`CStore`] with the crate metadata
+wrapped in the [`CrateMetadata`] struct. After resolution and expansion, the
+`CStore` will make its way into the [`GlobalCtxt`] for the rest of
+compilation.
+
+[name resolution]: ../name-resolution.md
+[`CrateLoader`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/creader/struct.CrateLoader.html
+[`CrateLocator`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/locator/struct.CrateLocator.html
+[`locator`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/locator/index.html
+[`CStore`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/creader/struct.CStore.html
+[`CrateMetadata`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/decoder/struct.CrateMetadata.html
+[`GlobalCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.GlobalCtxt.html
+[sysroot]: ../building/bootstrapping.md#what-is-a-sysroot
+
+## Pipelining
+
+One trick to improve compile times is to start building a crate as soon as the
+metadata for its dependencies is available. For a library, there is no need to
+wait for the code generation of dependencies to finish. Cargo implements this
+technique by telling `rustc` to emit an [`rmeta`](#rmeta) file for each
+dependency as well as an [`rlib`](#rlib). As early as it can, `rustc` will
+save the `rmeta` file to disk before it continues to the code generation
+phase. The compiler sends a JSON message to let the build tool know that it
+can start building the next crate if possible.
+
+The [crate loading](#crate-loading) system is smart enough to know when it
+sees an `rmeta` file to use that if the `rlib` is not there (or has only been
+partially written).
+
+This pipelining isn't possible for binaries, because the linking phase will
+require the code generation of all its dependencies. In the future, it may be
+possible to further improve this scenario by splitting linking into a separate
+command (see [#64191]).
+
+[#64191]: https://github.com/rust-lang/rust/issues/64191
+
+[metadata]: #metadata
diff --git a/src/doc/rustc-dev-guide/src/backend/lowering-mir.md b/src/doc/rustc-dev-guide/src/backend/lowering-mir.md
new file mode 100644
index 000000000..8b9dbe7ce
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/lowering-mir.md
@@ -0,0 +1,57 @@
+# Lowering MIR to a Codegen IR
+
+Now that we have a list of symbols to generate from the collector, we need to
+generate some sort of codegen IR. In this chapter, we will assume LLVM IR,
+since that's what rustc usually uses. The actual monomorphization is performed
+as we go, while we do the translation.
+
+Recall that the backend is started by
+[`rustc_codegen_ssa::base::codegen_crate`][codegen1]. Eventually, this reaches
+[`rustc_codegen_ssa::mir::codegen_mir`][codegen2], which does the lowering from
+MIR to LLVM IR.
+
+[codegen1]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/fn.codegen_crate.html
+[codegen2]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/fn.codegen_mir.html
+
+The code is split into modules which handle particular MIR primitives:
+
+- [`rustc_codegen_ssa::mir::block`][mirblk] will deal with translating
+  blocks and their terminators.  The most complicated and also the most
+  interesting thing this module does is generating code for function calls,
+  including the necessary unwinding handling IR.
+- [`rustc_codegen_ssa::mir::statement`][mirst] translates MIR statements.
+- [`rustc_codegen_ssa::mir::operand`][mirop] translates MIR operands.
+- [`rustc_codegen_ssa::mir::place`][mirpl] translates MIR place references.
+- [`rustc_codegen_ssa::mir::rvalue`][mirrv] translates MIR r-values.
+
+[mirblk]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/block/index.html
+[mirst]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/statement/index.html
+[mirop]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/operand/index.html
+[mirpl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/place/index.html
+[mirrv]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/rvalue/index.html
+
+Before a function is translated a number of simple and primitive analysis
+passes will run to help us generate simpler and more efficient LLVM IR. An
+example of such an analysis pass would be figuring out which variables are
+SSA-like, so that we can translate them to SSA directly rather than relying on
+LLVM's `mem2reg` for those variables. The analysis can be found in
+[`rustc_codegen_ssa::mir::analyze`][mirana].
+
+[mirana]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/analyze/index.html
+
+Usually a single MIR basic block will map to a LLVM basic block, with very few
+exceptions: intrinsic or function calls and less basic MIR statements like
+`assert` can result in multiple basic blocks. This is a perfect lede into the
+non-portable LLVM-specific part of the code generation. Intrinsic generation is
+fairly easy to understand as it involves very few abstraction levels in between
+and can be found in [`rustc_codegen_llvm::intrinsic`][llvmint].
+
+[llvmint]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/intrinsic/index.html
+
+Everything else will use the [builder interface][builder]. This is the code that gets
+called in the [`rustc_codegen_ssa::mir::*`][ssamir] modules discussed above.
+
+[builder]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/builder/index.html
+[ssamir]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/index.html
+
+> TODO: discuss how constants are generated
diff --git a/src/doc/rustc-dev-guide/src/backend/monomorph.md b/src/doc/rustc-dev-guide/src/backend/monomorph.md
new file mode 100644
index 000000000..416151ca9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/monomorph.md
@@ -0,0 +1,155 @@
+# Monomorphization
+
+<!-- toc -->
+
+As you probably know, Rust has a very expressive type system that has extensive
+support for generic types. But of course, assembly is not generic, so we need
+to figure out the concrete types of all the generics before the code can
+execute.
+
+Different languages handle this problem differently. For example, in some
+languages, such as Java, we may not know the most precise type of value until
+runtime. In the case of Java, this is ok because (almost) all variables are
+reference values anyway (i.e. pointers to a stack allocated object). This
+flexibility comes at the cost of performance, since all accesses to an object
+must dereference a pointer.
+
+Rust takes a different approach: it _monomorphizes_ all generic types. This
+means that compiler stamps out a different copy of the code of a generic
+function for each concrete type needed. For example, if I use a `Vec<u64>` and
+a `Vec<String>` in my code, then the generated binary will have two copies of
+the generated code for `Vec`: one for `Vec<u64>` and another for `Vec<String>`.
+The result is fast programs, but it comes at the cost of compile time (creating
+all those copies can take a while) and binary size (all those copies might take
+a lot of space).
+
+Monomorphization is the first step in the backend of the Rust compiler.
+
+## Collection
+
+First, we need to figure out what concrete types we need for all the generic
+things in our program. This is called _collection_, and the code that does this
+is called the _monomorphization collector_.
+
+Take this example:
+
+```rust
+fn banana() {
+   peach::<u64>();
+}
+
+fn main() {
+    banana();
+}
+```
+
+The monomorphization collector will give you a list of `[main, banana,
+peach::<u64>]`. These are the functions that will have machine code generated
+for them. Collector will also add things like statics to that list.
+
+See [the collector rustdocs][collect] for more info.
+
+[collect]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_monomorphize/collector/index.html
+
+The monomorphization collector is run just before MIR lowering and codegen.
+[`rustc_codegen_ssa::base::codegen_crate`][codegen1] calls the
+[`collect_and_partition_mono_items`][mono] query, which does monomorphization
+collection and then partitions them into [codegen
+units](../appendix/glossary.md#codegen-unit).
+
+## Codegen Unit (CGU) partitioning
+
+For better incremental build times, the CGU partitioner creates two CGU for each source level
+modules. One is for "stable" i.e. non-generic code and the other is more volatile code i.e.
+monomorphized/specialized instances.
+
+For dependencies, consider Crate A and Crate B, such that Crate B depends on Crate A.
+The following table lists different scenarios for a function in Crate A that might be used by one
+or more modules in Crate B.
+
+| Crate A function | Behavior |
+| - | - |
+| Non-generic function | Crate A function doesn't appear in any codegen units of Crate B |
+| Non-generic `#[inline]` function |  Crate A function appears with in a single CGU  of Crate B, and exists even after post-inlining stage|
+| Generic function |  Regardless of inlining, all monomorphized (specialized) functions <br> from Crate A appear within a single codegen unit for Crate B. <br> The codegen unit exists even after the post inlining stage.|
+| Generic `#[inline]` function |   - same - |
+
+For more details about the partitioner read the module level [documentation].
+
+[mono]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_monomorphize/partitioning/fn.collect_and_partition_mono_items.html
+[codegen1]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/fn.codegen_crate.html
+[documentation]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_monomorphize/partitioning/index.html
+
+## Polymorphization
+
+As mentioned above, monomorphization produces fast code, but it comes at the
+cost of compile time and binary size. [MIR optimizations][miropt] can help a
+bit with this.
+
+In addition to MIR optimizations, rustc attempts to determine when fewer
+copies of functions are necessary and avoid making those copies - known
+as "polymorphization". When a function-like item is found during
+monomorphization collection, the
+[`rustc_mir_monomorphize::polymorphize::unused_generic_params`][polymorph]
+query is invoked, which traverses the MIR of the item to determine on which
+generic parameters the item might not need duplicated.
+
+Currently, polymorphization only looks for unused generic parameters. These
+are relatively rare in functions, but closures inherit the generic
+parameters of their parent function and it is common for closures to not
+use those inherited parameters. Without polymorphization, a copy of these
+closures would be created for each copy of the parent function. By
+creating fewer copies, less LLVM IR is generated and needs processed.
+
+`unused_generic_params` returns a `FiniteBitSet<u64>` where a bit is set if
+the generic parameter of the corresponding index is unused. Any parameters
+after the first sixty-four are considered used.
+
+The results of polymorphization analysis are used in the
+[`Instance::polymorphize`][inst_polymorph] function to replace the
+[`Instance`][inst]'s substitutions for the unused generic parameters with their
+identity substitutions.
+
+Consider the example below:
+
+```rust
+fn foo<A, B>() {
+    let x: Option<B> = None;
+}
+
+fn main() {
+    foo::<u16, u32>();
+    foo::<u64, u32>();
+}
+```
+
+During monomorphization collection, `foo` will be collected with the
+substitutions `[u16, u32]` and `[u64, u32]` (from its invocations in `main`).
+`foo` has the identity substitutions `[A, B]` (or
+`[ty::Param(0), ty::Param(1)]`).
+
+Polymorphization will identify `A` as being unused and it will be replaced in
+the substitutions with the identity parameter before being added to the set
+of collected items - thereby reducing the copies from two (`[u16, u32]` and
+`[u64, u32]`) to one (`[A, u32]`).
+
+`unused_generic_params` will also invoked during code generation when the
+symbol name for `foo` is being computed for use in the callsites of `foo`
+(which have the regular substitutions present, otherwise there would be a
+symbol mismatch between the caller and the function).
+
+As a result of polymorphization, items collected during monomorphization
+cannot be assumed to be monomorphic.
+
+It is intended that polymorphization be extended to more advanced cases,
+such as where only the size/alignment of a generic parameter are required.
+
+More details on polymorphization are available in the
+[master's thesis][thesis] associated with polymorphization's initial
+implementation.
+
+[miropt]: ../mir/optimizations.md
+[polymorph]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_monomorphize/polymorphize/fn.unused_generic_params.html
+[inst]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/instance/struct.Instance.html
+[inst_polymorph]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/instance/struct.Instance.html#method.polymorphize
+[thesis]: https://davidtw.co/media/masters_dissertation.pdf
diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
new file mode 100644
index 000000000..0de0767b6
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -0,0 +1,194 @@
+# Updating LLVM
+
+<!-- toc -->
+
+The Rust compiler uses LLVM as its primary codegen backend today, and naturally
+we want to at least occasionally update this dependency! Currently we do not
+have a strict policy about when to update LLVM or what it can be updated to, but
+a few guidelines are applied:
+
+* We try to always support the latest released version of LLVM
+* We try to support the "last few" versions of LLVM (how many is changing over
+  time)
+* We allow moving to arbitrary commits during development.
+* Strongly prefer to upstream all patches to LLVM before including them in
+  rustc.
+
+This policy may change over time (or may actually start to exist as a formal
+policy!), but for now these are rough guidelines!
+
+## Why update LLVM?
+
+There are a few reasons nowadays that we want to update LLVM in one way or
+another:
+
+* A bug could have been fixed! Often we find bugs in the compiler and fix
+  them upstream in LLVM. We'll want to pull fixes back to the compiler itself as
+  they're merged upstream.
+
+* A new feature may be available in LLVM that we want to use in rustc,
+  but we don't want to wait for a full LLVM release to test it out.
+
+* LLVM itself may have a new release and we'd like to update to this LLVM
+  release.
+
+Each of these reasons has a different strategy for updating LLVM, and we'll go
+over them in detail here.
+
+## Bugfix Updates
+
+For updates of LLVM that are to fix a small bug, we cherry-pick the bugfix to
+the branch we're already using. The steps for this are:
+
+1. Make sure the bugfix is in upstream LLVM.
+2. Identify the branch that rustc is currently using. The `src/llvm-project`
+   submodule is always pinned to a branch of the
+   [rust-lang/llvm-project](https://github.com/rust-lang/llvm-project) repository.
+3. Fork the rust-lang/llvm-project repository
+4. Check out the appropriate branch (typically named `rustc/a.b-yyyy-mm-dd`)
+5. Cherry-pick the upstream commit onto the branch
+6. Push this branch to your fork
+7. Send a Pull Request to rust-lang/llvm-project to the same branch as before.
+   Be sure to reference the Rust and/or LLVM issue that you're fixing in the PR
+   description.
+8. Wait for the PR to be merged
+9. Send a PR to rust-lang/rust updating the `src/llvm-project` submodule with
+   your bugfix. This can be done locally with `git submodule update --remote
+   src/llvm-project` typically.
+10. Wait for PR to be merged
+
+The tl;dr; is that we can cherry-pick bugfixes at any time and pull them back
+into the rust-lang/llvm-project branch that we're using, and getting it into the
+compiler is just updating the submodule via a PR!
+
+Example PRs look like:
+[#59089](https://github.com/rust-lang/rust/pull/59089)
+
+## Feature updates
+
+> Note that this information is as of the time of this writing <!-- date:
+2021-10 --> (October 2021). The process for updating LLVM changes with
+practically all LLVM updates, so this may be out of date!
+
+Unlike bugfixes, updating to pick up a new feature of LLVM typically requires a
+lot more work. This is where we can't reasonably cherry-pick commits backwards
+so we need to do a full update. There's a lot of stuff to do here, so let's go
+through each in detail.
+
+1. Create a new branch in the [rust-lang/llvm-project repository]. This branch
+   should be named `rustc/a.b-yyyy-mm-dd` where `a.b` is the current version
+   number of LLVM in-tree at the time of the branch and the remaining part is
+   today's date. Move this branch to the commit in LLVM that you'd like, which
+   for this is probably the current LLVM HEAD.
+
+2. Apply Rust-specific patches to the llvm-project repository. All features and
+   bugfixes are upstream, but there's often some weird build-related patches
+   that don't make sense to upstream which we have on our repositories. These
+   patches are around the latest patches in the rust-lang/llvm-project branch
+   that rustc is currently using.
+
+3. Build the new LLVM in the `rust` repository. To do this you'll want to update
+   the `src/llvm-project` repository to your branch and the revision you've
+   created. It's also typically a good idea to update `.gitmodules` with the new
+   branch name of the LLVM submodule. Make sure you've committed changes to
+   `src/llvm-project` to ensure submodule updates aren't reverted. Some commands
+   you should execute are:
+
+   * `./x.py build src/llvm` - test that LLVM still builds
+   * `./x.py build src/tools/lld` - same for LLD
+   * `./x.py build` - build the rest of rustc
+
+   You'll likely need to update [`llvm-wrapper/*.cpp`][`llvm-wrapper`] to compile
+   with updated LLVM bindings. Note that you should use `#ifdef` and such to ensure
+   that the bindings still compile on older LLVM versions.
+
+   Note that `profile = "compiler"` and other defaults set by `./x.py setup`
+   download LLVM from CI instead of building it from source. You should
+   disable this temporarily to make sure your changes are being used, by setting
+   ```toml
+   [llvm]
+   download-ci-llvm = false
+   ```
+   in config.toml.
+
+4. Test for regressions across other platforms. LLVM often has at least one bug
+   for non-tier-1 architectures, so it's good to do some more testing before
+   sending this to bors! If you're low on resources you can send the PR as-is
+   now to bors, though, and it'll get tested anyway.
+
+   Ideally, build LLVM and test it on a few platforms:
+
+   * Linux
+   * macOS
+   * Windows
+
+   and afterwards run some docker containers that CI also does:
+
+   * `./src/ci/docker/run.sh wasm32`
+   * `./src/ci/docker/run.sh arm-android`
+   * `./src/ci/docker/run.sh dist-various-1`
+   * `./src/ci/docker/run.sh dist-various-2`
+   * `./src/ci/docker/run.sh armhf-gnu`
+
+5. Prepare a PR to `rust-lang/rust`. Work with maintainers of
+   `rust-lang/llvm-project` to get your commit in a branch of that repository,
+   and then you can send a PR to `rust-lang/rust`. You'll change at least
+   `src/llvm-project` and will likely also change [`llvm-wrapper`] as well.
+
+For prior art, previous LLVM updates look like
+[#62474](https://github.com/rust-lang/rust/pull/62474)
+[#62592](https://github.com/rust-lang/rust/pull/62592)
+[#67759](https://github.com/rust-lang/rust/pull/67759)
+[#73526](https://github.com/rust-lang/rust/pull/73526)
+[#81451](https://github.com/rust-lang/rust/pull/81451). Note that sometimes it's
+easiest to land [`llvm-wrapper`] compatibility as a PR before actually updating
+`src/llvm-project`. This way while you're working through LLVM issues others
+interested in trying out the new LLVM can benefit from work you've done to
+update the C++ bindings.
+
+[rust-lang/llvm-project repository]: https://github.com/rust-lang/llvm-project
+[`llvm-wrapper`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_llvm/llvm-wrapper
+
+### Caveats and gotchas
+
+Ideally the above instructions are pretty smooth, but here's some caveats to
+keep in mind while going through them:
+
+* LLVM bugs are hard to find, don't hesitate to ask for help! Bisection is
+  definitely your friend here (yes LLVM takes forever to build, yet bisection is
+  still your friend)
+* If you've got general questions, [wg-llvm] can help you out.
+* Creating branches is a privileged operation on GitHub, so you'll need someone
+  with write access to create the branches for you most likely.
+
+[wg-llvm]: https://rust-lang.zulipchat.com/#narrow/stream/187780-t-compiler.2Fwg-llvm
+
+## New LLVM Release Updates
+
+Updating to a new release of LLVM is very similar to the "feature updates"
+section above. The release process for LLVM is often months-long though and we
+like to ensure compatibility ASAP. The main tweaks to the "feature updates"
+section above is generally around branch naming. The sequence of events
+typically looks like:
+
+1. LLVM announces that its latest release version has branched. This will show
+   up as a branch in https://github.com/llvm/llvm-project typically named
+   `release/$N.x` where `$N` is the version of LLVM that's being released.
+
+2. We then follow the "feature updates" section above to create a new branch of
+   LLVM in our rust-lang/llvm-project repository. This follows the same naming
+   convention of branches as usual, except that `a.b` is the new version. This
+   update is eventually landed in the rust-lang/rust repository.
+
+3. Over the next few months, LLVM will continually push commits to its
+   `release/a.b` branch. Often those are bug fixes we'd like to have as well.
+   The merge process for that is to use `git merge` itself to merge LLVM's
+   `release/a.b` branch with the branch created in step 2. This is typically
+   done multiple times when necessary while LLVM's release branch is baking.
+
+4. LLVM then announces the release of version `a.b`.
+
+5. After LLVM's official release, we follow the "feature update" section again
+   to create a new branch in the rust-lang/llvm-project repository, this time
+   with a new date. The commit history should look much cleaner as just a few
+   Rust-specific commits stacked on top of stock LLVM's release branch.
diff --git a/src/doc/rustc-dev-guide/src/borrow_check.md b/src/doc/rustc-dev-guide/src/borrow_check.md
new file mode 100644
index 000000000..8e2bb752a
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check.md
@@ -0,0 +1,59 @@
+# MIR borrow check
+
+The borrow check is Rust's "secret sauce" – it is tasked with
+enforcing a number of properties:
+
+- That all variables are initialized before they are used.
+- That you can't move the same value twice.
+- That you can't move a value while it is borrowed.
+- That you can't access a place while it is mutably borrowed (except through
+  the reference).
+- That you can't mutate a place while it is immutably borrowed.
+- etc
+
+The borrow checker operates on the MIR. An older implementation operated on the
+HIR. Doing borrow checking on MIR has several advantages:
+
+- The MIR is *far* less complex than the HIR; the radical desugaring
+  helps prevent bugs in the borrow checker. (If you're curious, you
+  can see
+  [a list of bugs that the MIR-based borrow checker fixes here][47366].)
+- Even more importantly, using the MIR enables ["non-lexical lifetimes"][nll],
+  which are regions derived from the control-flow graph.
+
+[47366]: https://github.com/rust-lang/rust/issues/47366
+[nll]: https://rust-lang.github.io/rfcs/2094-nll.html
+
+### Major phases of the borrow checker
+
+The borrow checker source is found in
+[the `rustc_borrow_ck` crate][b_c]. The main entry point is
+the [`mir_borrowck`] query.
+
+[b_c]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/index.html
+[`mir_borrowck`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/fn.mir_borrowck.html
+
+- We first create a **local copy** of the MIR. In the coming steps,
+  we will modify this copy in place to modify the types and things to
+  include references to the new regions that we are computing.
+- We then invoke [`replace_regions_in_mir`] to modify our local MIR.
+  Among other things, this function will replace all of the [regions](./appendix/glossary.md#region)
+  in the MIR with fresh [inference variables](./appendix/glossary.md#inf-var).
+- Next, we perform a number of
+  [dataflow analyses](./appendix/background.md#dataflow) that
+  compute what data is moved and when.
+- We then do a [second type check](borrow_check/type_check.md) across the MIR:
+  the purpose of this type check is to determine all of the constraints between
+  different regions.
+- Next, we do [region inference](borrow_check/region_inference.md), which computes
+  the values of each region — basically, the points in the control-flow graph where
+  each lifetime must be valid according to the constraints we collected.
+- At this point, we can compute the "borrows in scope" at each point.
+- Finally, we do a second walk over the MIR, looking at the actions it
+  does and reporting errors. For example, if we see a statement like
+  `*a + 1`, then we would check that the variable `a` is initialized
+  and that it is not mutably borrowed, as either of those would
+  require an error to be reported. Doing this check requires the results of all
+  the previous analyses.
+
+[`replace_regions_in_mir`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/nll/fn.replace_regions_in_mir.html
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization.md b/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization.md
new file mode 100644
index 000000000..043db2f53
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization.md
@@ -0,0 +1,50 @@
+# Tracking moves and initialization
+
+Part of the borrow checker's job is to track which variables are
+"initialized" at any given point in time -- this also requires
+figuring out where moves occur and tracking those.
+
+## Initialization and moves
+
+From a user's perspective, initialization -- giving a variable some
+value -- and moves -- transferring ownership to another place -- might
+seem like distinct topics. Indeed, our borrow checker error messages
+often talk about them differently. But **within the borrow checker**,
+they are not nearly as separate. Roughly speaking, the borrow checker
+tracks the set of "initialized places" at any point in the source
+code. Assigning to a previously uninitialized local variable adds it
+to that set; moving from a local variable removes it from that set.
+
+Consider this example:
+
+```rust,ignore
+fn foo() {
+    let a: Vec<u32>;
+    
+    // a is not initialized yet
+    
+    a = vec![22];
+    
+    // a is initialized here
+    
+    std::mem::drop(a); // a is moved here
+    
+    // a is no longer initialized here
+
+    let l = a.len(); //~ ERROR
+}
+```
+
+Here you can see that `a` starts off as uninitialized; once it is
+assigned, it becomes initialized. But when `drop(a)` is called, that
+moves `a` into the call, and hence it becomes uninitialized again.
+
+## Subsections
+
+To make it easier to peruse, this section is broken into a number of
+subsections:
+
+- [Move paths](./moves_and_initialization/move_paths.html) the
+  *move path* concept that we use to track which local variables (or parts of
+  local variables, in some cases) are initialized.
+- TODO *Rest not yet written* =)
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization/move_paths.md b/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization/move_paths.md
new file mode 100644
index 000000000..4afec42f8
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/moves_and_initialization/move_paths.md
@@ -0,0 +1,129 @@
+# Move paths
+
+<!-- toc -->
+
+In reality, it's not enough to track initialization at the granularity
+of local variables. Rust also allows us to do moves and initialization
+at the field granularity:
+
+```rust,ignore
+fn foo() {
+    let a: (Vec<u32>, Vec<u32>) = (vec![22], vec![44]);
+
+    // a.0 and a.1 are both initialized
+
+    let b = a.0; // moves a.0
+
+    // a.0 is not initialized, but a.1 still is
+
+    let c = a.0; // ERROR
+    let d = a.1; // OK
+}
+```
+
+To handle this, we track initialization at the granularity of a **move
+path**. A [`MovePath`] represents some location that the user can
+initialize, move, etc. So e.g. there is a move-path representing the
+local variable `a`, and there is a move-path representing `a.0`.  Move
+paths roughly correspond to the concept of a [`Place`] from MIR, but
+they are indexed in ways that enable us to do move analysis more
+efficiently.
+
+[`MovePath`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePath.html
+[`Place`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Place.html
+
+## Move path indices
+
+Although there is a [`MovePath`] data structure, they are never referenced
+directly.  Instead, all the code passes around *indices* of type
+[`MovePathIndex`]. If you need to get information about a move path, you use
+this index with the [`move_paths` field of the `MoveData`][move_paths]. For
+example, to convert a [`MovePathIndex`] `mpi` into a MIR [`Place`], you might
+access the [`MovePath::place`] field like so:
+
+```rust,ignore
+move_data.move_paths[mpi].place
+```
+
+[move_paths]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MoveData.html#structfield.move_paths
+[`MovePath::place`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePath.html#structfield.place
+[`MovePathIndex`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePathIndex.html
+
+## Building move paths
+
+One of the first things we do in the MIR borrow check is to construct
+the set of move paths. This is done as part of the
+[`MoveData::gather_moves`] function. This function uses a MIR visitor
+called [`Gatherer`] to walk the MIR and look at how each [`Place`]
+within is accessed. For each such [`Place`], it constructs a
+corresponding [`MovePathIndex`]. It also records when/where that
+particular move path is moved/initialized, but we'll get to that in a
+later section.
+
+[`Gatherer`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/builder/struct.Gatherer.html
+[`MoveData::gather_moves`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MoveData.html#method.gather_moves
+
+### Illegal move paths
+
+We don't actually create a move-path for **every** [`Place`] that gets
+used.  In particular, if it is illegal to move from a [`Place`], then
+there is no need for a [`MovePathIndex`]. Some examples:
+
+- You cannot move from a static variable, so we do not create a [`MovePathIndex`]
+  for static variables.
+- You cannot move an individual element of an array, so if we have e.g. `foo: [String; 3]`,
+  there would be no move-path for `foo[1]`.
+- You cannot move from inside of a borrowed reference, so if we have e.g. `foo: &String`,
+  there would be no move-path for `*foo`.
+
+These rules are enforced by the [`move_path_for`] function, which
+converts a [`Place`] into a [`MovePathIndex`] -- in error cases like
+those just discussed, the function returns an `Err`. This in turn
+means we don't have to bother tracking whether those places are
+initialized (which lowers overhead).
+
+[`move_path_for`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/builder/struct.Gatherer.html#method.move_path_for
+
+## Looking up a move-path
+
+If you have a [`Place`] and you would like to convert it to a [`MovePathIndex`], you
+can do that using the [`MovePathLookup`] structure found in the [`rev_lookup`] field
+of [`MoveData`]. There are two different methods:
+
+[`MoveData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MoveData.html
+[`MovePathLookup`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePathLookup.html
+[`rev_lookup`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MoveData.html#structfield.rev_lookup
+
+- [`find_local`], which takes a [`mir::Local`] representing a local
+  variable. This is the easier method, because we **always** create a
+  [`MovePathIndex`] for every local variable.
+- [`find`], which takes an arbitrary [`Place`]. This method is a bit
+  more annoying to use, precisely because we don't have a
+  [`MovePathIndex`] for **every** [`Place`] (as we just discussed in
+  the "illegal move paths" section). Therefore, [`find`] returns a
+  [`LookupResult`] indicating the closest path it was able to find
+  that exists (e.g., for `foo[1]`, it might return just the path for
+  `foo`).
+
+[`find`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePathLookup.html#method.find
+[`find_local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MovePathLookup.html#method.find_local
+[`mir::Local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Local.html
+[`LookupResult`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/enum.LookupResult.html
+
+## Cross-references
+
+As we noted above, move-paths are stored in a big vector and
+referenced via their [`MovePathIndex`]. However, within this vector,
+they are also structured into a tree. So for example if you have the
+[`MovePathIndex`] for `a.b.c`, you can go to its parent move-path
+`a.b`. You can also iterate over all children paths: so, from `a.b`,
+you might iterate to find the path `a.b.c` (here you are iterating
+just over the paths that are **actually referenced** in the source,
+not all **possible** paths that could have been referenced). These
+references are used for example in the
+[`find_in_move_path_or_its_descendants`] function, which determines
+whether a move-path (e.g., `a.b`) or any child of that move-path
+(e.g.,`a.b.c`) matches a given predicate.
+
+[`Place`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Place.html
+[`find_in_move_path_or_its_descendants`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/move_paths/struct.MoveData.html#method.find_in_move_path_or_its_descendants
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md
new file mode 100644
index 000000000..330c079b9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference.md
@@ -0,0 +1,238 @@
+# Region inference (NLL)
+
+<!-- toc -->
+
+The MIR-based region checking code is located in [the `rustc_mir::borrow_check`
+module][nll].
+
+[nll]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/index.html
+
+The MIR-based region analysis consists of two major functions:
+
+- [`replace_regions_in_mir`], invoked first, has two jobs:
+  - First, it finds the set of regions that appear within the
+    signature of the function (e.g., `'a` in `fn foo<'a>(&'a u32) {
+    ... }`). These are called the "universal" or "free" regions – in
+    particular, they are the regions that [appear free][fvb] in the
+    function body.
+  - Second, it replaces all the regions from the function body with
+    fresh inference variables. This is because (presently) those
+    regions are the results of lexical region inference and hence are
+    not of much interest. The intention is that – eventually – they
+    will be "erased regions" (i.e., no information at all), since we
+    won't be doing lexical region inference at all.
+- [`compute_regions`], invoked second: this is given as argument the
+  results of move analysis. It has the job of computing values for all
+  the inference variables that `replace_regions_in_mir` introduced.
+  - To do that, it first runs the [MIR type checker]. This is
+    basically a normal type-checker but specialized to MIR, which is
+    much simpler than full Rust, of course. Running the MIR type
+    checker will however create various [constraints][cp] between region
+    variables, indicating their potential values and relationships to
+    one another.
+  - After this, we perform [constraint propagation][cp] by creating a
+    [`RegionInferenceContext`] and invoking its [`solve`]
+    method.
+  - The [NLL RFC] also includes fairly thorough (and hopefully readable)
+    coverage.
+
+[cp]: ./region_inference/constraint_propagation.md
+[fvb]: ../appendix/background.md#free-vs-bound
+[`replace_regions_in_mir`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/nll/fn.replace_regions_in_mir.html
+[`compute_regions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/nll/fn.compute_regions.html
+[`RegionInferenceContext`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html
+[`solve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.solve
+[NLL RFC]: https://rust-lang.github.io/rfcs/2094-nll.html
+[MIR type checker]: ./type_check.md
+
+## Universal regions
+
+The [`UniversalRegions`] type represents a collection of _universal_ regions
+corresponding to some MIR `DefId`. It is constructed in
+[`replace_regions_in_mir`] when we replace all regions with fresh inference
+variables. [`UniversalRegions`] contains indices for all the free regions in
+the given MIR along with any relationships that are _known_ to hold between
+them (e.g. implied bounds, where clauses, etc.).
+
+For example, given the MIR for the following function:
+
+```rust
+fn foo<'a>(x: &'a u32) {
+    // ...
+}
+```
+
+we would create a universal region for `'a` and one for `'static`. There may
+also be some complications for handling closures, but we will ignore those for
+the moment.
+
+TODO: write about _how_ these regions are computed.
+
+[`UniversalRegions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/universal_regions/struct.UniversalRegions.html
+
+<a name="region-variables"></a>
+
+## Region variables
+
+The value of a region can be thought of as a **set**. This set contains all
+points in the MIR where the region is valid along with any regions that are
+outlived by this region (e.g. if `'a: 'b`, then `end('b)` is in the set for
+`'a`); we call the domain of this set a `RegionElement`. In the code, the value
+for all regions is maintained in [the `rustc_borrowck::region_infer` module][ri].
+For each region we maintain a set storing what elements are present in its value (to make this
+efficient, we give each kind of element an index, the `RegionElementIndex`, and
+use sparse bitsets).
+
+[ri]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_borrowck/src/region_infer
+
+The kinds of region elements are as follows:
+
+- Each **[`location`]** in the MIR control-flow graph: a location is just
+  the pair of a basic block and an index. This identifies the point
+  **on entry** to the statement with that index (or the terminator, if
+  the index is equal to `statements.len()`).
+- There is an element `end('a)` for each universal region `'a`,
+  corresponding to some portion of the caller's (or caller's caller,
+  etc) control-flow graph.
+- Similarly, there is an element denoted `end('static)` corresponding
+  to the remainder of program execution after this function returns.
+- There is an element `!1` for each placeholder region `!1`. This
+  corresponds (intuitively) to some unknown set of other elements –
+  for details on placeholders, see the section
+  [placeholders and universes](region_inference/placeholders_and_universes.md).
+
+## Constraints
+
+Before we can infer the value of regions, we need to collect
+constraints on the regions. The full set of constraints is described
+in [the section on constraint propagation][cp], but the two most
+common sorts of constraints are:
+
+1. Outlives constraints. These are constraints that one region outlives another
+   (e.g. `'a: 'b`). Outlives constraints are generated by the [MIR type
+   checker].
+2. Liveness constraints. Each region needs to be live at points where it can be
+   used. These constraints are collected by [`generate_constraints`].
+
+[`generate_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/constraint_generation/fn.generate_constraints.html
+
+## Inference Overview
+
+So how do we compute the contents of a region? This process is called _region
+inference_. The high-level idea is pretty simple, but there are some details we
+need to take care of.
+
+Here is the high-level idea: we start off each region with the MIR locations we
+know must be in it from the liveness constraints. From there, we use all of the
+outlives constraints computed from the type checker to _propagate_ the
+constraints: for each region `'a`, if `'a: 'b`, then we add all elements of
+`'b` to `'a`, including `end('b)`. This all happens in
+[`propagate_constraints`].
+
+Then, we will check for errors. We first check that type tests are satisfied by
+calling [`check_type_tests`]. This checks constraints like `T: 'a`. Second, we
+check that universal regions are not "too big". This is done by calling
+[`check_universal_regions`]. This checks that for each region `'a` if `'a`
+contains the element `end('b)`, then we must already know that `'a: 'b` holds
+(e.g. from a where clause). If we don't already know this, that is an error...
+well, almost. There is some special handling for closures that we will discuss
+later.
+
+### Example
+
+Consider the following example:
+
+```rust,ignore
+fn foo<'a, 'b>(x: &'a usize) -> &'b usize {
+    x
+}
+```
+
+Clearly, this should not compile because we don't know if `'a` outlives `'b`
+(if it doesn't then the return value could be a dangling reference).
+
+Let's back up a bit. We need to introduce some free inference variables (as is
+done in [`replace_regions_in_mir`]). This example doesn't use the exact regions
+produced, but it (hopefully) is enough to get the idea across.
+
+```rust,ignore
+fn foo<'a, 'b>(x: &'a /* '#1 */ usize) -> &'b /* '#3 */ usize {
+    x // '#2, location L1
+}
+```
+
+Some notation: `'#1`, `'#3`, and `'#2` represent the universal regions for the
+argument, return value, and the expression `x`, respectively. Additionally, I
+will call the location of the expression `x` `L1`.
+
+So now we can use the liveness constraints to get the following starting points:
+
+Region  | Contents
+--------|----------
+'#1     |
+'#2     | `L1`
+'#3     | `L1`
+
+Now we use the outlives constraints to expand each region. Specifically, we
+know that `'#2: '#3` ...
+
+Region  | Contents
+--------|----------
+'#1     | `L1`
+'#2     | `L1, end('#3) // add contents of '#3 and end('#3)`
+'#3     | `L1`
+
+... and `'#1: '#2`, so ...
+
+Region  | Contents
+--------|----------
+'#1     | `L1, end('#2), end('#3) // add contents of '#2 and end('#2)`
+'#2     | `L1, end('#3)`
+'#3     | `L1`
+
+Now, we need to check that no regions were too big (we don't have any type
+tests to check in this case). Notice that `'#1` now contains `end('#3)`, but
+we have no `where` clause or implied bound to say that `'a: 'b`... that's an
+error!
+
+### Some details
+
+The [`RegionInferenceContext`] type contains all of the information needed to
+do inference, including the universal regions from [`replace_regions_in_mir`] and
+the constraints computed for each region. It is constructed just after we
+compute the liveness constraints.
+
+Here are some of the fields of the struct:
+
+- [`constraints`]: contains all the outlives constraints.
+- [`liveness_constraints`]: contains all the liveness constraints.
+- [`universal_regions`]: contains the `UniversalRegions` returned by
+  [`replace_regions_in_mir`].
+- [`universal_region_relations`]: contains relations known to be true about
+  universal regions. For example, if we have a where clause that `'a: 'b`, that
+  relation is assumed to be true while borrow checking the implementation (it
+  is checked at the caller), so `universal_region_relations` would contain `'a:
+  'b`.
+- [`type_tests`]: contains some constraints on types that we must check after
+  inference (e.g. `T: 'a`).
+- [`closure_bounds_mapping`]: used for propagating region constraints from
+  closures back out to the creator of the closure.
+
+[`constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.constraints
+[`liveness_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.liveness_constraints
+[`location`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Location.html
+[`universal_regions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.universal_regions
+[`universal_region_relations`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.universal_region_relations
+[`type_tests`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.type_tests
+[`closure_bounds_mapping`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.closure_bounds_mapping
+
+TODO: should we discuss any of the others fields? What about the SCCs?
+
+Ok, now that we have constructed a `RegionInferenceContext`, we can do
+inference. This is done by calling the [`solve`] method on the context. This
+is where we call [`propagate_constraints`] and then check the resulting type
+tests and universal regions, as discussed above.
+
+[`propagate_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.propagate_constraints
+[`check_type_tests`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.check_type_tests
+[`check_universal_regions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.check_universal_regions
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/closure_constraints.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/closure_constraints.md
new file mode 100644
index 000000000..13230d037
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/closure_constraints.md
@@ -0,0 +1,10 @@
+# Propagating closure constraints
+
+When we are checking the type tests and universal regions, we may come
+across a constraint that we can't prove yet if we are in a closure
+body! However, the necessary constraints may actually hold (we just
+don't know it yet). Thus, if we are inside a closure, we just collect
+all the constraints we can't prove yet and return them. Later, when we
+are borrow check the MIR node that created the closure, we can also
+check that these constraints hold. At that time, if we can't prove
+they hold, we report an error.
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/constraint_propagation.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/constraint_propagation.md
new file mode 100644
index 000000000..4c30d25e0
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/constraint_propagation.md
@@ -0,0 +1,224 @@
+# Constraint propagation
+
+<!-- toc -->
+
+The main work of the region inference is **constraint propagation**,
+which is done in the [`propagate_constraints`] function.  There are
+three sorts of constraints that are used in NLL, and we'll explain how
+`propagate_constraints` works by "layering" those sorts of constraints
+on one at a time (each of them is fairly independent from the others):
+
+- liveness constraints (`R live at E`), which arise from liveness;
+- outlives constraints (`R1: R2`), which arise from subtyping;
+- [member constraints][m_c] (`member R_m of [R_c...]`), which arise from impl Trait.
+
+[`propagate_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.propagate_constraints
+[m_c]: ./member_constraints.md
+
+In this chapter, we'll explain the "heart" of constraint propagation,
+covering both liveness and outlives constraints.
+
+## Notation and high-level concepts
+
+Conceptually, region inference is a "fixed-point" computation. It is
+given some set of constraints `{C}` and it computes a set of values
+`Values: R -> {E}` that maps each region `R` to a set of elements
+`{E}` (see [here][riv] for more notes on region elements):
+
+- Initially, each region is mapped to an empty set, so `Values(R) =
+  {}` for all regions `R`.
+- Next, we process the constraints repeatedly until a fixed-point is reached:
+  - For each constraint C:
+    - Update `Values` as needed to satisfy the constraint
+
+[riv]: ../region_inference.md#region-variables
+
+As a simple example, if we have a liveness constraint `R live at E`,
+then we can apply `Values(R) = Values(R) union {E}` to make the
+constraint be satisfied. Similarly, if we have an outlives constraints
+`R1: R2`, we can apply `Values(R1) = Values(R1) union Values(R2)`.
+(Member constraints are more complex and we discuss them [in this section][m_c].)
+
+In practice, however, we are a bit more clever. Instead of applying
+the constraints in a loop, we can analyze the constraints and figure
+out the correct order to apply them, so that we only have to apply
+each constraint once in order to find the final result.
+
+Similarly, in the implementation, the `Values` set is stored in the
+`scc_values` field, but they are indexed not by a *region* but by a
+*strongly connected component* (SCC). SCCs are an optimization that
+avoids a lot of redundant storage and computation.  They are explained
+in the section on outlives constraints.
+
+## Liveness constraints
+
+A **liveness constraint** arises when some variable whose type
+includes a region R is live at some [point] P. This simply means that
+the value of R must include the point P. Liveness constraints are
+computed by the MIR type checker.
+
+[point]: ../../appendix/glossary.md#point
+
+A liveness constraint `R live at E` is satisfied if `E` is a member of
+`Values(R)`. So to "apply" such a constraint to `Values`, we just have
+to compute `Values(R) = Values(R) union {E}`.
+
+The liveness values are computed in the type-check and passed to the
+region inference upon creation in the `liveness_constraints` argument.
+These are not represented as individual constraints like `R live at E`
+though; instead, we store a (sparse) bitset per region variable (of
+type [`LivenessValues`]). This way we only need a single bit for each
+liveness constraint.
+
+[`liveness_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.liveness_constraints
+[`LivenessValues`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/values/struct.LivenessValues.html
+
+One thing that is worth mentioning: All lifetime parameters are always
+considered to be live over the entire function body. This is because
+they correspond to some portion of the *caller's* execution, and that
+execution clearly includes the time spent in this function, since the
+caller is waiting for us to return.
+
+## Outlives constraints
+
+An outlives constraint `'a: 'b` indicates that the value of `'a` must
+be a **superset** of the value of `'b`. That is, an outlives
+constraint `R1: R2` is satisfied if `Values(R1)` is a superset of
+`Values(R2)`. So to "apply" such a constraint to `Values`, we just
+have to compute `Values(R1) = Values(R1) union Values(R2)`.
+
+One observation that follows from this is that if you have `R1: R2`
+and `R2: R1`, then `R1 = R2` must be true. Similarly, if you have:
+
+```txt
+R1: R2
+R2: R3
+R3: R4
+R4: R1
+```
+
+then `R1 = R2 = R3 = R4` follows. We take advantage of this to make things
+much faster, as described shortly.
+
+In the code, the set of outlives constraints is given to the region
+inference context on creation in a parameter of type
+[`OutlivesConstraintSet`]. The constraint set is basically just a list of `'a:
+'b` constraints.
+
+### The outlives constraint graph and SCCs
+
+In order to work more efficiently with outlives constraints, they are
+[converted into the form of a graph][graph-fn], where the nodes of the
+graph are region variables (`'a`, `'b`) and each constraint `'a: 'b`
+induces an edge `'a -> 'b`. This conversion happens in the
+[`RegionInferenceContext::new`] function that creates the inference
+context.
+
+[`OutlivesConstraintSet`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/constraints/struct.OutlivesConstraintSet.html
+[graph-fn]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/constraints/struct.OutlivesConstraintSet.html#method.graph
+[`RegionInferenceContext::new`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.new
+
+When using a graph representation, we can detect regions that must be equal
+by looking for cycles. That is, if you have a constraint like
+
+```txt
+'a: 'b
+'b: 'c
+'c: 'd
+'d: 'a
+```
+
+then this will correspond to a cycle in the graph containing the
+elements `'a...'d`.
+
+Therefore, one of the first things that we do in propagating region
+values is to compute the **strongly connected components** (SCCs) in
+the constraint graph. The result is stored in the [`constraint_sccs`]
+field. You can then easily find the SCC that a region `r` is a part of
+by invoking `constraint_sccs.scc(r)`.
+
+Working in terms of SCCs allows us to be more efficient: if we have a
+set of regions `'a...'d` that are part of a single SCC, we don't have
+to compute/store their values separately. We can just store one value
+**for the SCC**, since they must all be equal.
+
+If you look over the region inference code, you will see that a number
+of fields are defined in terms of SCCs. For example, the
+[`scc_values`] field stores the values of each SCC. To get the value
+of a specific region `'a` then, we first figure out the SCC that the
+region is a part of, and then find the value of that SCC.
+
+[`constraint_sccs`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.constraint_sccs
+[`scc_values`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#structfield.scc_values
+
+When we compute SCCs, we not only figure out which regions are a
+member of each SCC, we also figure out the edges between them. So for example
+consider this set of outlives constraints:
+
+```txt
+'a: 'b
+'b: 'a
+
+'a: 'c
+
+'c: 'd
+'d: 'c
+```
+
+Here we have two SCCs: S0 contains `'a` and `'b`, and S1 contains `'c`
+and `'d`.  But these SCCs are not independent: because `'a: 'c`, that
+means that `S0: S1` as well. That is -- the value of `S0` must be a
+superset of the value of `S1`. One crucial thing is that this graph of
+SCCs is always a DAG -- that is, it never has cycles. This is because
+all the cycles have been removed to form the SCCs themselves.
+
+### Applying liveness constraints to SCCs
+
+The liveness constraints that come in from the type-checker are
+expressed in terms of regions -- that is, we have a map like
+`Liveness: R -> {E}`.  But we want our final result to be expressed
+in terms of SCCs -- we can integrate these liveness constraints very
+easily just by taking the union:
+
+```txt
+for each region R:
+  let S be the SCC that contains R
+  Values(S) = Values(S) union Liveness(R)
+```
+
+In the region inferencer, this step is done in [`RegionInferenceContext::new`].
+
+### Applying outlives constraints
+
+Once we have computed the DAG of SCCs, we use that to structure out
+entire computation. If we have an edge `S1 -> S2` between two SCCs,
+that means that `Values(S1) >= Values(S2)` must hold. So, to compute
+the value of `S1`, we first compute the values of each successor `S2`.
+Then we simply union all of those values together. To use a
+quasi-iterator-like notation:
+
+```txt
+Values(S1) =
+  s1.successors()
+    .map(|s2| Values(s2))
+    .union()
+```
+
+In the code, this work starts in the [`propagate_constraints`]
+function, which iterates over all the SCCs. For each SCC `S1`, we
+compute its value by first computing the value of its
+successors. Since SCCs form a DAG, we don't have to be concerned about
+cycles, though we do need to keep a set around to track whether we
+have already processed a given SCC or not. For each successor `S2`, once
+we have computed `S2`'s value, we can union those elements into the
+value for `S1`. (Although we have to be careful in this process to
+properly handle [higher-ranked
+placeholders](./placeholders_and_universes.html). Note that the value
+for `S1` already contains the liveness constraints, since they were
+added in [`RegionInferenceContext::new`].
+
+Once that process is done, we now have the "minimal value" for `S1`,
+taking into account all of the liveness and outlives
+constraints. However, in order to complete the process, we must also
+consider [member constraints][m_c], which are described in [a later
+section][m_c].
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/error_reporting.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/error_reporting.md
new file mode 100644
index 000000000..79b3e077c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/error_reporting.md
@@ -0,0 +1,3 @@
+# Reporting region errors
+
+TODO: we should discuss how to generate errors from the results of these analyses.
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/lifetime_parameters.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/lifetime_parameters.md
new file mode 100644
index 000000000..2dbbc0c1e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/lifetime_parameters.md
@@ -0,0 +1,127 @@
+# Universal regions
+
+<!-- toc -->
+
+"Universal regions" is the name that the code uses to refer to "named
+lifetimes" -- e.g., lifetime parameters and `'static`. The name
+derives from the fact that such lifetimes are "universally quantified"
+(i.e., we must make sure the code is true for all values of those
+lifetimes). It is worth spending a bit of discussing how lifetime
+parameters are handled during region inference. Consider this example:
+
+```rust,ignore
+fn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> &'b u32 {
+  x
+}
+```
+
+This example is intended not to compile, because we are returning `x`,
+which has type `&'a u32`, but our signature promises that we will
+return a `&'b u32` value. But how are lifetimes like `'a` and `'b`
+integrated into region inference, and how this error wind up being
+detected?
+
+## Universal regions and their relationships to one another
+
+Early on in region inference, one of the first things we do is to
+construct a [`UniversalRegions`] struct. This struct tracks the
+various universal regions in scope on a particular function.  We also
+create a [`UniversalRegionRelations`] struct, which tracks their
+relationships to one another. So if you have e.g. `where 'a: 'b`, then
+the [`UniversalRegionRelations`] struct would track that `'a: 'b` is
+known to hold (which could be tested with the [`outlives`] function.
+
+[`UniversalRegions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/universal_regions/struct.UniversalRegions.html
+[`UniversalRegionRelations`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/type_check/free_region_relations/struct.UniversalRegionRelations.html
+[`outlives`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/type_check/free_region_relations/struct.UniversalRegionRelations.html#method.outlives
+
+## Everything is a region variable
+
+One important aspect of how NLL region inference works is that **all
+lifetimes** are represented as numbered variables. This means that the
+only variant of [`ty::RegionKind`] that we use is the [`ReVar`]
+variant. These region variables are broken into two major categories,
+based on their index:
+
+[`ty::RegionKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.RegionKind.html
+[`ReVar`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.RegionKind.html#variant.ReVar
+
+- 0..N: universal regions -- the ones we are discussing here. In this
+  case, the code must be correct with respect to any value of those
+  variables that meets the declared relationships.
+- N..M: existential regions -- inference variables where the region
+  inferencer is tasked with finding *some* suitable value.
+
+In fact, the universal regions can be further subdivided based on
+where they were brought into scope (see the [`RegionClassification`]
+type). These subdivisions are not important for the topics discussed
+here, but become important when we consider [closure constraint
+propagation](./closure_constraints.html), so we discuss them there.
+
+[`RegionClassification`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/universal_regions/enum.RegionClassification.html#variant.Local
+
+## Universal lifetimes as the elements of a region's value
+
+As noted previously, the value that we infer for each region is a set
+`{E}`. The elements of this set can be points in the control-flow
+graph, but they can also be an element `end('a)` corresponding to each
+universal lifetime `'a`. If the value for some region `R0` includes
+`end('a`), then this implies that `R0` must extend until the end of `'a`
+in the caller.
+
+## The "value" of a universal region
+
+During region inference, we compute a value for each universal region
+in the same way as we compute values for other regions. This value
+represents, effectively, the **lower bound** on that universal region
+-- the things that it must outlive. We now describe how we use this
+value to check for errors.
+
+## Liveness and universal regions
+
+All universal regions have an initial liveness constraint that
+includes the entire function body. This is because lifetime parameters
+are defined in the caller and must include the entirety of the
+function call that invokes this particular function. In addition, each
+universal region `'a` includes itself (that is, `end('a)`) in its
+liveness constraint (i.e., `'a` must extend until the end of
+itself). In the code, these liveness constraints are setup in
+[`init_free_and_bound_regions`].
+
+[`init_free_and_bound_regions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.init_free_and_bound_regions
+
+## Propagating outlives constraints for universal regions
+
+So, consider the first example of this section:
+
+```rust,ignore
+fn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> &'b u32 {
+  x
+}
+```
+
+Here, returning `x` requires that `&'a u32 <: &'b u32`, which gives
+rise to an outlives constraint `'a: 'b`. Combined with our default liveness
+constraints we get:
+
+```txt
+'a live at {B, end('a)} // B represents the "function body"
+'b live at {B, end('b)}
+'a: 'b
+```
+
+When we process the `'a: 'b` constraint, therefore, we will add
+`end('b)` into the value for `'a`, resulting in a final value of `{B,
+end('a), end('b)}`.
+
+## Detecting errors
+
+Once we have finished constraint propagation, we then enforce a
+constraint that if some universal region `'a` includes an element
+`end('b)`, then `'a: 'b` must be declared in the function's bounds. If
+not, as in our example, that is an error. This check is done in the
+[`check_universal_regions`] function, which simply iterates over all
+universal regions, inspects their final value, and tests against the
+declared [`UniversalRegionRelations`].
+
+[`check_universal_regions`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/region_infer/struct.RegionInferenceContext.html#method.check_universal_regions
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
new file mode 100644
index 000000000..c7c107e1e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
@@ -0,0 +1,193 @@
+# Member constraints
+
+<!-- toc -->
+
+A member constraint `'m member of ['c_1..'c_N]` expresses that the
+region `'m` must be *equal* to some **choice regions** `'c_i` (for
+some `i`). These constraints cannot be expressed by users, but they
+arise from `impl Trait` due to its lifetime capture rules. Consider a
+function such as the following:
+
+```rust,ignore
+fn make(a: &'a u32, b: &'b u32) -> impl Trait<'a, 'b> { .. }
+```
+
+Here, the true return type (often called the "hidden type") is only
+permitted to capture the lifetimes `'a` or `'b`. You can kind of see
+this more clearly by desugaring that `impl Trait` return type into its
+more explicit form:
+
+```rust,ignore
+type MakeReturn<'x, 'y> = impl Trait<'x, 'y>;
+fn make(a: &'a u32, b: &'b u32) -> MakeReturn<'a, 'b> { .. }
+```
+
+Here, the idea is that the hidden type must be some type that could
+have been written in place of the `impl Trait<'x, 'y>` -- but clearly
+such a type can only reference the regions `'x` or `'y` (or
+`'static`!), as those are the only names in scope. This limitation is
+then translated into a restriction to only access `'a` or `'b` because
+we are returning `MakeReturn<'a, 'b>`, where `'x` and `'y` have been
+replaced with `'a` and `'b` respectively.
+
+## Detailed example
+
+To help us explain member constraints in more detail, let's spell out
+the `make` example in a bit more detail. First off, let's assume that
+you have some dummy trait:
+
+```rust,ignore
+trait Trait<'a, 'b> { }
+impl<T> Trait<'_, '_> for T { }
+```
+
+and this is the `make` function (in desugared form):
+
+```rust,ignore
+type MakeReturn<'x, 'y> = impl Trait<'x, 'y>;
+fn make(a: &'a u32, b: &'b u32) -> MakeReturn<'a, 'b> {
+  (a, b)
+}
+```
+
+What happens in this case is that the return type will be `(&'0 u32, &'1 u32)`,
+where `'0` and `'1` are fresh region variables. We will have the following
+region constraints:
+
+```txt
+'0 live at {L}
+'1 live at {L}
+'a: '0
+'b: '1
+'0 member of ['a, 'b, 'static]
+'1 member of ['a, 'b, 'static]
+```
+
+Here the "liveness set" `{L}` corresponds to that subset of the body
+where `'0` and `'1` are live -- basically the point from where the
+return tuple is constructed to where it is returned (in fact, `'0` and
+`'1` might have slightly different liveness sets, but that's not very
+interesting to the point we are illustrating here).
+
+The `'a: '0` and `'b: '1` constraints arise from subtyping. When we
+construct the `(a, b)` value, it will be assigned type `(&'0 u32, &'1
+u32)` -- the region variables reflect that the lifetimes of these
+references could be made smaller. For this value to be created from
+`a` and `b`, however, we do require that:
+
+```txt
+(&'a u32, &'b u32) <: (&'0 u32, &'1 u32)
+```
+
+which means in turn that `&'a u32 <: &'0 u32` and hence that `'a: '0`
+(and similarly that `&'b u32 <: &'1 u32`, `'b: '1`).
+
+Note that if we ignore member constraints, the value of `'0` would be
+inferred to some subset of the function body (from the liveness
+constraints, which we did not write explicitly). It would never become
+`'a`, because there is no need for it too -- we have a constraint that
+`'a: '0`, but that just puts a "cap" on how *large* `'0` can grow to
+become. Since we compute the *minimal* value that we can, we are happy
+to leave `'0` as being just equal to the liveness set. This is where
+member constraints come in.
+
+## Choices are always lifetime parameters
+
+At present, the "choice" regions from a member constraint are always lifetime
+parameters from the current function. As of <!-- date: 2021-10 --> October 2021,
+this falls out from the placement of impl Trait, though in the future it may not
+be the case. We take some advantage of this fact, as it simplifies the current
+code. In particular, we don't have to consider a case like `'0 member of ['1,
+'static]`, in which the value of both `'0` and `'1` are being inferred and hence
+changing. See [rust-lang/rust#61773][#61773] for more information.
+
+[#61773]: https://github.com/rust-lang/rust/issues/61773
+
+## Applying member constraints
+
+Member constraints are a bit more complex than other forms of
+constraints. This is because they have a "or" quality to them -- that
+is, they describe multiple choices that we must select from. E.g., in
+our example constraint `'0 member of ['a, 'b, 'static]`, it might be
+that `'0` is equal to `'a`, `'b`, *or* `'static`. How can we pick the
+correct one?  What we currently do is to look for a *minimal choice*
+-- if we find one, then we will grow `'0` to be equal to that minimal
+choice. To find that minimal choice, we take two factors into
+consideration: lower and upper bounds.
+
+### Lower bounds
+
+The *lower bounds* are those lifetimes that `'0` *must outlive* --
+i.e., that `'0` must be larger than. In fact, when it comes time to
+apply member constraints, we've already *computed* the lower bounds of
+`'0` because we computed its minimal value (or at least, the lower
+bounds considering everything but member constraints).
+
+Let `LB` be the current value of `'0`. We know then that `'0: LB` must
+hold, whatever the final value of `'0` is. Therefore, we can rule out
+any choice `'choice` where `'choice: LB` does not hold.
+
+Unfortunately, in our example, this is not very helpful. The lower
+bound for `'0` will just be the liveness set `{L}`, and we know that
+all the lifetime parameters outlive that set. So we are left with the
+same set of choices here. (But in other examples, particularly those
+with different variance, lower bound constraints may be relevant.)
+
+### Upper bounds
+
+The *upper bounds* are those lifetimes that *must outlive* `'0` --
+i.e., that `'0` must be *smaller* than. In our example, this would be
+`'a`, because we have the constraint that `'a: '0`. In more complex
+examples, the chain may be more indirect.
+
+We can use upper bounds to rule out members in a very similar way to
+lower bounds. If UB is some upper bound, then we know that `UB:
+'0` must hold, so we can rule out any choice `'choice` where `UB:
+'choice` does not hold.
+
+In our example, we would be able to reduce our choice set from `['a,
+'b, 'static]` to just `['a]`. This is because `'0` has an upper bound
+of `'a`, and neither `'a: 'b` nor `'a: 'static` is known to hold.
+
+(For notes on how we collect upper bounds in the implementation, see
+[the section below](#collecting).)
+
+### Minimal choice
+
+After applying lower and upper bounds, we can still sometimes have
+multiple possibilities. For example, imagine a variant of our example
+using types with the opposite variance. In that case, we would have
+the constraint `'0: 'a` instead of `'a: '0`. Hence the current value
+of `'0` would be `{L, 'a}`. Using this as a lower bound, we would be
+able to narrow down the member choices to `['a, 'static]` because `'b:
+'a` is not known to hold (but `'a: 'a` and `'static: 'a` do hold). We
+would not have any upper bounds, so that would be our final set of choices.
+
+In that case, we apply the **minimal choice** rule -- basically, if
+one of our choices if smaller than the others, we can use that. In
+this case, we would opt for `'a` (and not `'static`).
+
+This choice is consistent with the general 'flow' of region
+propagation, which always aims to compute a minimal value for the
+region being inferred. However, it is somewhat arbitrary.
+
+<a name="collecting"></a>
+
+### Collecting upper bounds in the implementation
+
+In practice, computing upper bounds is a bit inconvenient, because our
+data structures are setup for the opposite. What we do is to compute
+the **reverse SCC graph** (we do this lazily and cache the result) --
+that is, a graph where `'a: 'b` induces an edge `SCC('b) ->
+SCC('a)`. Like the normal SCC graph, this is a DAG. We can then do a
+depth-first search starting from `SCC('0)` in this graph. This will
+take us to all the SCCs that must outlive `'0`.
+
+One wrinkle is that, as we walk the "upper bound" SCCs, their values
+will not yet have been fully computed. However, we **have** already
+applied their liveness constraints, so we have some information about
+their value. In particular, for any regions representing lifetime
+parameters, their value will contain themselves (i.e., the initial
+value for `'a` includes `'a` and the value for `'b` contains `'b`). So
+we can collect all of the lifetime parameters that are reachable,
+which is precisely what we are interested in.
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/placeholders_and_universes.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/placeholders_and_universes.md
new file mode 100644
index 000000000..91c8c4526
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/placeholders_and_universes.md
@@ -0,0 +1,442 @@
+# Placeholders and universes
+
+<!-- toc -->
+
+From time to time we have to reason about regions that we can't
+concretely know. For example, consider this program:
+
+```rust,ignore
+// A function that needs a static reference
+fn foo(x: &'static u32) { }
+
+fn bar(f: for<'a> fn(&'a u32)) {
+       // ^^^^^^^^^^^^^^^^^^^ a function that can accept **any** reference
+    let x = 22;
+    f(&x);
+}
+
+fn main() {
+    bar(foo);
+}
+```
+
+This program ought not to type-check: `foo` needs a static reference
+for its argument, and `bar` wants to be given a function that
+accepts **any** reference (so it can call it with something on its
+stack, for example). But *how* do we reject it and *why*?
+
+## Subtyping and Placeholders
+
+When we type-check `main`, and in particular the call `bar(foo)`, we
+are going to wind up with a subtyping relationship like this one:
+
+```text
+fn(&'static u32) <: for<'a> fn(&'a u32)
+----------------    -------------------
+the type of `foo`   the type `bar` expects
+```
+
+We handle this sort of subtyping by taking the variables that are
+bound in the supertype and replacing them with
+[universally quantified](../../appendix/background.md#quantified)
+representatives, denoted like `!1` here. We call these regions "placeholder
+regions" – they represent, basically, "some unknown region".
+
+Once we've done that replacement, we have the following relation:
+
+```text
+fn(&'static u32) <: fn(&'!1 u32)
+```
+
+The key idea here is that this unknown region `'!1` is not related to
+any other regions. So if we can prove that the subtyping relationship
+is true for `'!1`, then it ought to be true for any region, which is
+what we wanted.
+
+So let's work through what happens next. To check if two functions are
+subtypes, we check if their arguments have the desired relationship
+(fn arguments are [contravariant](../../appendix/background.md#variance), so
+we swap the left and right here):
+
+```text
+&'!1 u32 <: &'static u32
+```
+
+According to the basic subtyping rules for a reference, this will be
+true if `'!1: 'static`. That is – if "some unknown region `!1`" outlives `'static`.
+Now, this *might* be true – after all, `'!1` could be `'static` –
+but we don't *know* that it's true. So this should yield up an error (eventually).
+
+## What is a universe?
+
+In the previous section, we introduced the idea of a placeholder
+region, and we denoted it `!1`. We call this number `1` the **universe
+index**. The idea of a "universe" is that it is a set of names that
+are in scope within some type or at some point. Universes are formed
+into a tree, where each child extends its parents with some new names.
+So the **root universe** conceptually contains global names, such as
+the lifetime `'static` or the type `i32`. In the compiler, we also
+put generic type parameters into this root universe (in this sense,
+there is not just one root universe, but one per item). So consider
+this function `bar`:
+
+```rust,ignore
+struct Foo { }
+
+fn bar<'a, T>(t: &'a T) {
+    ...
+}
+```
+
+Here, the root universe would consist of the lifetimes `'static` and
+`'a`.  In fact, although we're focused on lifetimes here, we can apply
+the same concept to types, in which case the types `Foo` and `T` would
+be in the root universe (along with other global types, like `i32`).
+Basically, the root universe contains all the names that
+[appear free](../../appendix/background.md#free-vs-bound) in the body of `bar`.
+
+Now let's extend `bar` a bit by adding a variable `x`:
+
+```rust,ignore
+fn bar<'a, T>(t: &'a T) {
+    let x: for<'b> fn(&'b u32) = ...;
+}
+```
+
+Here, the name `'b` is not part of the root universe. Instead, when we
+"enter" into this `for<'b>` (e.g., by replacing it with a placeholder), we will create
+a child universe of the root, let's call it U1:
+
+```text
+U0 (root universe)
+│
+└─ U1 (child universe)
+```
+
+The idea is that this child universe U1 extends the root universe U0
+with a new name, which we are identifying by its universe number:
+`!1`.
+
+Now let's extend `bar` a bit by adding one more variable, `y`:
+
+```rust,ignore
+fn bar<'a, T>(t: &'a T) {
+    let x: for<'b> fn(&'b u32) = ...;
+    let y: for<'c> fn(&'c u32) = ...;
+}
+```
+
+When we enter *this* type, we will again create a new universe, which
+we'll call `U2`. Its parent will be the root universe, and U1 will be
+its sibling:
+
+```text
+U0 (root universe)
+│
+├─ U1 (child universe)
+│
+└─ U2 (child universe)
+```
+
+This implies that, while in U2, we can name things from U0 or U2, but
+not U1.
+
+**Giving existential variables a universe.** Now that we have this
+notion of universes, we can use it to extend our type-checker and
+things to prevent illegal names from leaking out. The idea is that we
+give each inference (existential) variable – whether it be a type or
+a lifetime – a universe. That variable's value can then only
+reference names visible from that universe. So for example if a
+lifetime variable is created in U0, then it cannot be assigned a value
+of `!1` or `!2`, because those names are not visible from the universe
+U0.
+
+**Representing universes with just a counter.** You might be surprised
+to see that the compiler doesn't keep track of a full tree of
+universes. Instead, it just keeps a counter – and, to determine if
+one universe can see another one, it just checks if the index is
+greater. For example, U2 can see U0 because 2 >= 0. But U0 cannot see
+U2, because 0 >= 2 is false.
+
+How can we get away with this? Doesn't this mean that we would allow
+U2 to also see U1? The answer is that, yes, we would, **if that
+question ever arose**.  But because of the structure of our type
+checker etc, there is no way for that to happen. In order for
+something happening in the universe U1 to "communicate" with something
+happening in U2, they would have to have a shared inference variable X
+in common. And because everything in U1 is scoped to just U1 and its
+children, that inference variable X would have to be in U0. And since
+X is in U0, it cannot name anything from U1 (or U2). This is perhaps easiest
+to see by using a kind of generic "logic" example:
+
+```text
+exists<X> {
+   forall<Y> { ... /* Y is in U1 ... */ }
+   forall<Z> { ... /* Z is in U2 ... */ }
+}
+```
+
+Here, the only way for the two foralls to interact would be through X,
+but neither Y nor Z are in scope when X is declared, so its value
+cannot reference either of them.
+
+## Universes and placeholder region elements
+
+But where does that error come from?  The way it happens is like this.
+When we are constructing the region inference context, we can tell
+from the type inference context how many placeholder variables exist
+(the `InferCtxt` has an internal counter). For each of those, we
+create a corresponding universal region variable `!n` and a "region
+element" `placeholder(n)`. This corresponds to "some unknown set of other
+elements". The value of `!n` is `{placeholder(n)}`.
+
+At the same time, we also give each existential variable a
+**universe** (also taken from the `InferCtxt`). This universe
+determines which placeholder elements may appear in its value: For
+example, a variable in universe U3 may name `placeholder(1)`, `placeholder(2)`, and
+`placeholder(3)`, but not `placeholder(4)`. Note that the universe of an inference
+variable controls what region elements **can** appear in its value; it
+does not say region elements **will** appear.
+
+## Placeholders and outlives constraints
+
+In the region inference engine, outlives constraints have the form:
+
+```text
+V1: V2 @ P
+```
+
+where `V1` and `V2` are region indices, and hence map to some region
+variable (which may be universally or existentially quantified). The
+`P` here is a "point" in the control-flow graph; it's not important
+for this section. This variable will have a universe, so let's call
+those universes `U(V1)` and `U(V2)` respectively. (Actually, the only
+one we are going to care about is `U(V1)`.)
+
+When we encounter this constraint, the ordinary procedure is to start
+a DFS from `P`. We keep walking so long as the nodes we are walking
+are present in `value(V2)` and we add those nodes to `value(V1)`. If
+we reach a return point, we add in any `end(X)` elements. That part
+remains unchanged.
+
+But then *after that* we want to iterate over the placeholder `placeholder(x)`
+elements in V2 (each of those must be visible to `U(V2)`, but we
+should be able to just assume that is true, we don't have to check
+it). We have to ensure that `value(V1)` outlives each of those
+placeholder elements.
+
+Now there are two ways that could happen. First, if `U(V1)` can see
+the universe `x` (i.e., `x <= U(V1)`), then we can just add `placeholder(x)`
+to `value(V1)` and be done. But if not, then we have to approximate:
+we may not know what set of elements `placeholder(x)` represents, but we
+should be able to compute some sort of **upper bound** B for it –
+some region B that outlives `placeholder(x)`. For now, we'll just use
+`'static` for that (since it outlives everything) – in the future, we
+can sometimes be smarter here (and in fact we have code for doing this
+already in other contexts). Moreover, since `'static` is in the root
+universe U0, we know that all variables can see it – so basically if
+we find that `value(V2)` contains `placeholder(x)` for some universe `x`
+that `V1` can't see, then we force `V1` to `'static`.
+
+## Extending the "universal regions" check
+
+After all constraints have been propagated, the NLL region inference
+has one final check, where it goes over the values that wound up being
+computed for each universal region and checks that they did not get
+'too large'. In our case, we will go through each placeholder region
+and check that it contains *only* the `placeholder(u)` element it is known to
+outlive. (Later, we might be able to know that there are relationships
+between two placeholder regions and take those into account, as we do
+for universal regions from the fn signature.)
+
+Put another way, the "universal regions" check can be considered to be
+checking constraints like:
+
+```text
+{placeholder(1)}: V1
+```
+
+where `{placeholder(1)}` is like a constant set, and V1 is the variable we
+made to represent the `!1` region.
+
+## Back to our example
+
+OK, so far so good. Now let's walk through what would happen with our
+first example:
+
+```text
+fn(&'static u32) <: fn(&'!1 u32) @ P  // this point P is not imp't here
+```
+
+The region inference engine will create a region element domain like this:
+
+```text
+{ CFG; end('static); placeholder(1) }
+  ---  ------------  ------- from the universe `!1`
+  |    'static is always in scope
+  all points in the CFG; not especially relevant here
+```
+
+It will always create two universal variables, one representing
+`'static` and one representing `'!1`. Let's call them Vs and V1. They
+will have initial values like so:
+
+```text
+Vs = { CFG; end('static) } // it is in U0, so can't name anything else
+V1 = { placeholder(1) }
+```
+
+From the subtyping constraint above, we would have an outlives constraint like
+
+```text
+'!1: 'static @ P
+```
+
+To process this, we would grow the value of V1 to include all of Vs:
+
+```text
+Vs = { CFG; end('static) }
+V1 = { CFG; end('static), placeholder(1) }
+```
+
+At that point, constraint propagation is complete, because all the
+outlives relationships are satisfied. Then we would go to the "check
+universal regions" portion of the code, which would test that no
+universal region grew too large.
+
+In this case, `V1` *did* grow too large – it is not known to outlive
+`end('static)`, nor any of the CFG – so we would report an error.
+
+## Another example
+
+What about this subtyping relationship?
+
+```text
+for<'a> fn(&'a u32, &'a u32)
+    <:
+for<'b, 'c> fn(&'b u32, &'c u32)
+```
+
+Here we would replace the bound region in the supertype with a placeholder, as before, yielding:
+
+```text
+for<'a> fn(&'a u32, &'a u32)
+    <:
+fn(&'!1 u32, &'!2 u32)
+```
+
+then we instantiate the variable on the left-hand side with an
+existential in universe U2, yielding the following (`?n` is a notation
+for an existential variable):
+
+```text
+fn(&'?3 u32, &'?3 u32)
+    <:
+fn(&'!1 u32, &'!2 u32)
+```
+
+Then we break this down further:
+
+```text
+&'!1 u32 <: &'?3 u32
+&'!2 u32 <: &'?3 u32
+```
+
+and even further, yield up our region constraints:
+
+```text
+'!1: '?3
+'!2: '?3
+```
+
+Note that, in this case, both `'!1` and `'!2` have to outlive the
+variable `'?3`, but the variable `'?3` is not forced to outlive
+anything else. Therefore, it simply starts and ends as the empty set
+of elements, and hence the type-check succeeds here.
+
+(This should surprise you a little. It surprised me when I first realized it.
+We are saying that if we are a fn that **needs both of its arguments to have
+the same region**, we can accept being called with **arguments with two
+distinct regions**. That seems intuitively unsound. But in fact, it's fine, as
+I tried to explain in [this issue][ohdeargoditsallbroken] on the Rust issue
+tracker long ago.  The reason is that even if we get called with arguments of
+two distinct lifetimes, those two lifetimes have some intersection (the call
+itself), and that intersection can be our value of `'a` that we use as the
+common lifetime of our arguments. -nmatsakis)
+
+[ohdeargoditsallbroken]: https://github.com/rust-lang/rust/issues/32330#issuecomment-202536977
+
+## Final example
+
+Let's look at one last example. We'll extend the previous one to have
+a return type:
+
+```text
+for<'a> fn(&'a u32, &'a u32) -> &'a u32
+    <:
+for<'b, 'c> fn(&'b u32, &'c u32) -> &'b u32
+```
+
+Despite seeming very similar to the previous example, this case is going to get
+an error. That's good: the problem is that we've gone from a fn that promises
+to return one of its two arguments, to a fn that is promising to return the
+first one. That is unsound. Let's see how it plays out.
+
+First, we replace the bound region in the supertype with a placeholder:
+
+```text
+for<'a> fn(&'a u32, &'a u32) -> &'a u32
+    <:
+fn(&'!1 u32, &'!2 u32) -> &'!1 u32
+```
+
+Then we instantiate the subtype with existentials (in U2):
+
+```text
+fn(&'?3 u32, &'?3 u32) -> &'?3 u32
+    <:
+fn(&'!1 u32, &'!2 u32) -> &'!1 u32
+```
+
+And now we create the subtyping relationships:
+
+```text
+&'!1 u32 <: &'?3 u32 // arg 1
+&'!2 u32 <: &'?3 u32 // arg 2
+&'?3 u32 <: &'!1 u32 // return type
+```
+
+And finally the outlives relationships. Here, let V1, V2, and V3 be the
+variables we assign to `!1`, `!2`, and `?3` respectively:
+
+```text
+V1: V3
+V2: V3
+V3: V1
+```
+
+Those variables will have these initial values:
+
+```text
+V1 in U1 = {placeholder(1)}
+V2 in U2 = {placeholder(2)}
+V3 in U2 = {}
+```
+
+Now because of the `V3: V1` constraint, we have to add `placeholder(1)` into `V3` (and
+indeed it is visible from `V3`), so we get:
+
+```text
+V3 in U2 = {placeholder(1)}
+```
+
+then we have this constraint `V2: V3`, so we wind up having to enlarge
+`V2` to include `placeholder(1)` (which it can also see):
+
+```text
+V2 in U2 = {placeholder(1), placeholder(2)}
+```
+
+Now constraint propagation is done, but when we check the outlives
+relationships, we find that `V2` includes this new element `placeholder(1)`,
+so we report an error.
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/two_phase_borrows.md b/src/doc/rustc-dev-guide/src/borrow_check/two_phase_borrows.md
new file mode 100644
index 000000000..bcd487821
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/two_phase_borrows.md
@@ -0,0 +1,100 @@
+# Two-phase borrows
+
+Two-phase borrows are a more permissive version of mutable borrows that allow
+nested method calls such as `vec.push(vec.len())`. Such borrows first act as
+shared borrows in a "reservation" phase and can later be "activated" into a
+full mutable borrow.
+
+Only certain implicit mutable borrows can be two-phase, any `&mut` or `ref mut`
+in the source code is never a two-phase borrow. The cases where we generate a
+two-phase borrow are:
+
+1. The autoref borrow when calling a method with a mutable reference receiver.
+2. A mutable reborrow in function arguments.
+3. The implicit mutable borrow in an overloaded compound assignment operator.
+
+To give some examples:
+
+```rust2018
+// In the source code
+
+// Case 1:
+let mut v = Vec::new();
+v.push(v.len());
+let r = &mut Vec::new();
+r.push(r.len());
+
+// Case 2:
+std::mem::replace(r, vec![1, r.len()]);
+
+// Case 3:
+let mut x = std::num::Wrapping(2);
+x += x;
+```
+
+Expanding these enough to show the two-phase borrows:
+
+```rust,ignore
+// Case 1:
+let mut v = Vec::new();
+let temp1 = &two_phase v;
+let temp2 = v.len();
+Vec::push(temp1, temp2);
+let r = &mut Vec::new();
+let temp3 = &two_phase *r;
+let temp4 = r.len();
+Vec::push(temp3, temp4);
+
+// Case 2:
+let temp5 = &two_phase *r;
+let temp6 = vec![1, r.len()];
+std::mem::replace(temp5, temp6);
+
+// Case 3:
+let mut x = std::num::Wrapping(2);
+let temp7 = &two_phase x;
+let temp8 = x;
+std::ops::AddAssign::add_assign(temp7, temp8);
+```
+
+Whether a borrow can be two-phase is tracked by a flag on the [`AutoBorrow`]
+after type checking, which is then [converted] to a [`BorrowKind`] during MIR
+construction.
+
+Each two-phase borrow is assigned to a temporary that is only used once. As
+such we can define:
+
+* The point where the temporary is assigned to is called the *reservation*
+  point of the two-phase borrow.
+* The point where the temporary is used, which is effectively always a
+  function call, is called the *activation* point.
+
+The activation points are found using the [`GatherBorrows`] visitor. The
+[`BorrowData`] then holds both the reservation and activation points for the
+borrow.
+
+[`AutoBorrow`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/adjustment/enum.AutoBorrow.html
+[converted]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/cx/expr/trait.ToBorrowKind.html#method.to_borrow_kind
+[`BorrowKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.BorrowKind.html
+[`GatherBorrows`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/visit/trait.Visitor.html#method.visit_local
+[`BorrowData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/borrow_set/struct.BorrowData.html
+
+## Checking two-phase borrows
+
+Two-phase borrows are treated as if they were mutable borrows with the
+following exceptions:
+
+1. At every location in the MIR we [check] if any two-phase borrows are
+   activated at this location. If a live two phase borrow is activated at a
+   location, then we check that there are no borrows that conflict with the
+   two-phase borrow.
+2. At the reservation point we error if there are conflicting live *mutable*
+   borrows. And lint if there are any conflicting shared borrows.
+3. Between the reservation and the activation point, the two-phase borrow acts
+   as a shared borrow. We determine (in [`is_active`]) if we're at such a point
+   by using the [`Dominators`] for the MIR graph.
+4. After the activation point, the two-phase borrow acts as a mutable borrow.
+
+[check]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/struct.MirBorrowckCtxt.html#method.check_activations
+[`Dominators`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/graph/dominators/struct.Dominators.html
+[`is_active`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/path_utils/fn.is_active.html
diff --git a/src/doc/rustc-dev-guide/src/borrow_check/type_check.md b/src/doc/rustc-dev-guide/src/borrow_check/type_check.md
new file mode 100644
index 000000000..69456d870
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/borrow_check/type_check.md
@@ -0,0 +1,64 @@
+# The MIR type-check
+
+A key component of the borrow check is the
+[MIR type-check](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/type_check/index.html).
+This check walks the MIR and does a complete "type check" -- the same
+kind you might find in any other language. In the process of doing
+this type-check, we also uncover the region constraints that apply to
+the program.
+
+TODO -- elaborate further? Maybe? :)
+
+## User types
+
+At the start of MIR type-check, we replace all regions in the body with new unconstrained regions.
+However, this would cause us to accept the following program:
+```rust
+fn foo<'a>(x: &'a u32) {
+    let y: &'static u32 = x;
+}
+```
+By erasing the lifetimes in the type of `y` we no longer know that it is supposed to be `'static`,
+ignoring the intentions of the user.
+
+To deal with this we remember all places where the user explicitly mentioned a type during
+HIR type-check as [`CanonicalUserTypeAnnotations`][annot].
+
+There are two different annotations we care about:
+- explicit type ascriptions, e.g. `let y: &'static u32` results in `UserType::Ty(&'static u32)`.
+- explicit generic arguments, e.g. `x.foo<&'a u32, Vec<String>>`
+results in `UserType::TypeOf(foo_def_id, [&'a u32, Vec<String>])`.
+
+As we do not want the region inference from the HIR type-check to influence MIR typeck,
+we store the user type right after lowering it from the HIR.
+This means that it may still contain inference variables,
+which is why we are using **canonical** user type annotations.
+We replace all inference variables with existential bound variables instead.
+Something like `let x: Vec<_>` would therefore result in `exists<T> UserType::Ty(Vec<T>)`.
+
+A pattern like `let Foo(x): Foo<&'a u32>` has a user type `Foo<&'a u32>` but
+the actual type of `x` should only be `&'a u32`. For this, we use a [`UserTypeProjection`][proj].
+
+In the MIR, we deal with user types in two slightly different ways.
+
+Given a MIR local corresponding to a variable in a pattern which has an explicit type annotation,
+we require the type of that local to be equal to the type of the [`UserTypeProjection`][proj].
+This is directly stored in the [`LocalDecl`][decl].
+
+We also constrain the type of scrutinee expressions, e.g. the type of `x` in `let _: &'a u32 = x;`.
+Here `T_x` only has to be a subtype of the user type, so we instead use
+[`StatementKind::AscribeUserType`][stmt] for that.
+
+Note that we do not directly use the user type as the MIR typechecker
+doesn't really deal with type and const inference variables. We instead store the final
+[`inferred_type`][inf] from the HIR type-checker. During MIR typeck, we then replace its regions
+with new nll inference vars and relate it with the actual `UserType` to get the correct region
+constraints again.
+
+After the MIR type-check, all user type annotations get discarded, as they aren't needed anymore.
+
+[annot]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.CanonicalUserTypeAnnotation.html
+[proj]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.UserTypeProjection.html
+[decl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.LocalDecl.html
+[stmt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.StatementKind.html#variant.AscribeUserType
+[inf]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.CanonicalUserTypeAnnotation.html#structfield.inferred_ty
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/bug-fix-procedure.md b/src/doc/rustc-dev-guide/src/bug-fix-procedure.md
new file mode 100644
index 000000000..8702f8aa9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/bug-fix-procedure.md
@@ -0,0 +1,334 @@
+# Rustc Bug Fix Procedure
+
+<!-- toc -->
+
+This page defines the best practices procedure for making bug fixes or soundness
+corrections in the compiler that can cause existing code to stop compiling. This
+text is based on
+[RFC 1589](https://github.com/rust-lang/rfcs/blob/master/text/1589-rustc-bug-fix-procedure.md).
+
+# Motivation
+
+[motivation]: #motivation
+
+From time to time, we encounter the need to make a bug fix, soundness
+correction, or other change in the compiler which will cause existing code to
+stop compiling. When this happens, it is important that we handle the change in
+a way that gives users of Rust a smooth transition. What we want to avoid is
+that existing programs suddenly stop compiling with opaque error messages: we
+would prefer to have a gradual period of warnings, with clear guidance as to
+what the problem is, how to fix it, and why the change was made. This RFC
+describes the procedure that we have been developing for handling breaking
+changes that aims to achieve that kind of smooth transition.
+
+One of the key points of this policy is that (a) warnings should be issued
+initially rather than hard errors if at all possible and (b) every change that
+causes existing code to stop compiling will have an associated tracking issue.
+This issue provides a point to collect feedback on the results of that change.
+Sometimes changes have unexpectedly large consequences or there may be a way to
+avoid the change that was not considered. In those cases, we may decide to
+change course and roll back the change, or find another solution (if warnings
+are being used, this is particularly easy to do).
+
+### What qualifies as a bug fix?
+
+Note that this RFC does not try to define when a breaking change is permitted.
+That is already covered under [RFC 1122][]. This document assumes that the
+change being made is in accordance with those policies. Here is a summary of the
+conditions from RFC 1122:
+
+- **Soundness changes:** Fixes to holes uncovered in the type system.
+- **Compiler bugs:** Places where the compiler is not implementing the specified
+  semantics found in an RFC or lang-team decision.
+- **Underspecified language semantics:** Clarifications to grey areas where the
+  compiler behaves inconsistently and no formal behavior had been previously
+  decided.
+
+Please see [the RFC][rfc 1122] for full details!
+
+# Detailed design
+
+[design]: #detailed-design
+
+The procedure for making a breaking change is as follows (each of these steps is
+described in more detail below):
+
+0. Do a **crater run** to assess the impact of the change.
+1. Make a **special tracking issue** dedicated to the change.
+1. Do not report an error right away. Instead, **issue forwards-compatibility
+   lint warnings**.
+   - Sometimes this is not straightforward. See the text below for suggestions
+     on different techniques we have employed in the past.
+   - For cases where warnings are infeasible:
+     - Report errors, but make every effort to give a targeted error message
+       that directs users to the tracking issue
+     - Submit PRs to all known affected crates that fix the issue
+       - or, at minimum, alert the owners of those crates to the problem and
+         direct them to the tracking issue
+1. Once the change has been in the wild for at least one cycle, we can
+   **stabilize the change**, converting those warnings into errors.
+
+Finally, for changes to `rustc_ast` that will affect plugins, the general policy
+is to batch these changes. That is discussed below in more detail.
+
+### Tracking issue
+
+Every breaking change should be accompanied by a **dedicated tracking issue**
+for that change. The main text of this issue should describe the change being
+made, with a focus on what users must do to fix their code. The issue should be
+approachable and practical; it may make sense to direct users to an RFC or some
+other issue for the full details. The issue also serves as a place where users
+can comment with questions or other concerns.
+
+A template for these breaking-change tracking issues can be found below. An
+example of how such an issue should look can be [found
+here][breaking-change-issue].
+
+The issue should be tagged with (at least) `B-unstable` and `T-compiler`.
+
+### Tracking issue template
+
+This is a template to use for tracking issues:
+
+```
+This is the **summary issue** for the `YOUR_LINT_NAME_HERE`
+future-compatibility warning and other related errors. The goal of
+this page is describe why this change was made and how you can fix
+code that is affected by it. It also provides a place to ask questions
+or register a complaint if you feel the change should not be made. For
+more information on the policy around future-compatibility warnings,
+see our [breaking change policy guidelines][guidelines].
+
+[guidelines]: LINK_TO_THIS_RFC
+
+#### What is the warning for?
+
+*Describe the conditions that trigger the warning and how they can be
+fixed. Also explain why the change was made.**
+
+#### When will this warning become a hard error?
+
+At the beginning of each 6-week release cycle, the Rust compiler team
+will review the set of outstanding future compatibility warnings and
+nominate some of them for **Final Comment Period**. Toward the end of
+the cycle, we will review any comments and make a final determination
+whether to convert the warning into a hard error or remove it
+entirely.
+```
+
+### Issuing future compatibility warnings
+
+The best way to handle a breaking change is to begin by issuing
+future-compatibility warnings. These are a special category of lint warning.
+Adding a new future-compatibility warning can be done as follows.
+
+```rust
+// 1. Define the lint in `compiler/rustc_middle/src/lint/builtin.rs`:
+declare_lint! {
+    pub YOUR_ERROR_HERE,
+    Warn,
+    "illegal use of foo bar baz"
+}
+
+// 2. Add to the list of HardwiredLints in the same file:
+impl LintPass for HardwiredLints {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(
+            ..,
+            YOUR_ERROR_HERE
+        )
+    }
+}
+
+// 3. Register the lint in `compiler/rustc_lint/src/lib.rs`:
+store.register_future_incompatible(sess, vec![
+    ...,
+    FutureIncompatibleInfo {
+        id: LintId::of(YOUR_ERROR_HERE),
+        reference: "issue #1234", // your tracking issue here!
+    },
+]);
+
+// 4. Report the lint:
+tcx.lint_node(
+    lint::builtin::YOUR_ERROR_HERE,
+    path_id,
+    binding.span,
+    format!("some helper message here"));
+```
+
+#### Helpful techniques
+
+It can often be challenging to filter out new warnings from older, pre-existing
+errors. One technique that has been used in the past is to run the older code
+unchanged and collect the errors it would have reported. You can then issue
+warnings for any errors you would give which do not appear in that original set.
+Another option is to abort compilation after the original code completes if
+errors are reported: then you know that your new code will only execute when
+there were no errors before.
+
+#### Crater and crates.io
+
+We should always do a crater run to assess impact. It is polite and considerate
+to at least notify the authors of affected crates the breaking change. If we can
+submit PRs to fix the problem, so much the better.
+
+#### Is it ever acceptable to go directly to issuing errors?
+
+Changes that are believed to have negligible impact can go directly to issuing
+an error. One rule of thumb would be to check against `crates.io`: if fewer than
+10 **total** affected projects are found (**not** root errors), we can move
+straight to an error. In such cases, we should still make the "breaking change"
+page as before, and we should ensure that the error directs users to this page.
+In other words, everything should be the same except that users are getting an
+error, and not a warning. Moreover, we should submit PRs to the affected
+projects (ideally before the PR implementing the change lands in rustc).
+
+If the impact is not believed to be negligible (e.g., more than 10 crates are
+affected), then warnings are required (unless the compiler team agrees to grant
+a special exemption in some particular case). If implementing warnings is not
+feasible, then we should make an aggressive strategy of migrating crates before
+we land the change so as to lower the number of affected crates. Here are some
+techniques for approaching this scenario:
+
+1. Issue warnings for subparts of the problem, and reserve the new errors for
+   the smallest set of cases you can.
+2. Try to give a very precise error message that suggests how to fix the problem
+   and directs users to the tracking issue.
+3. It may also make sense to layer the fix:
+   - First, add warnings where possible and let those land before proceeding to
+     issue errors.
+   - Work with authors of affected crates to ensure that corrected versions are
+     available _before_ the fix lands, so that downstream users can use them.
+
+### Stabilization
+
+After a change is made, we will **stabilize** the change using the same process
+that we use for unstable features:
+
+- After a new release is made, we will go through the outstanding tracking
+  issues corresponding to breaking changes and nominate some of them for **final
+  comment period** (FCP).
+- The FCP for such issues lasts for one cycle. In the final week or two of the
+  cycle, we will review comments and make a final determination:
+
+  - Convert to error: the change should be made into a hard error.
+  - Revert: we should remove the warning and continue to allow the older code to
+    compile.
+  - Defer: can't decide yet, wait longer, or try other strategies.
+
+Ideally, breaking changes should have landed on the **stable branch** of the
+compiler before they are finalized.
+
+<a name="guide">
+
+### Removing a lint
+
+Once we have decided to make a "future warning" into a hard error, we need a PR
+that removes the custom lint. As an example, here are the steps required to
+remove the `overlapping_inherent_impls` compatibility lint. First, convert the
+name of the lint to uppercase (`OVERLAPPING_INHERENT_IMPLS`) ripgrep through the
+source for that string. We will basically by converting each place where this
+lint name is mentioned (in the compiler, we use the upper-case name, and a macro
+automatically generates the lower-case string; so searching for
+`overlapping_inherent_impls` would not find much).
+
+> NOTE: these exact files don't exist anymore, but the procedure is still the same.
+
+#### Remove the lint.
+
+The first reference you will likely find is the lint definition [in
+`rustc_session/src/lint/builtin.rs` that resembles this][defsource]:
+
+[defsource]: https://github.com/rust-lang/rust/blob/085d71c3efe453863739c1fb68fd9bd1beff214f/src/librustc/lint/builtin.rs#L171-L175
+
+```rust
+declare_lint! {
+    pub OVERLAPPING_INHERENT_IMPLS,
+    Deny, // this may also say Warning
+    "two overlapping inherent impls define an item with the same name were erroneously allowed"
+}
+```
+
+This `declare_lint!` macro creates the relevant data structures. Remove it. You
+will also find that there is a mention of `OVERLAPPING_INHERENT_IMPLS` later in
+the file as [part of a `lint_array!`][lintarraysource]; remove it too.
+
+[lintarraysource]: https://github.com/rust-lang/rust/blob/085d71c3efe453863739c1fb68fd9bd1beff214f/src/librustc/lint/builtin.rs#L252-L290
+
+Next, you see [a reference to `OVERLAPPING_INHERENT_IMPLS` in
+`rustc_lint/src/lib.rs`][futuresource]. This is defining the lint as a "future
+compatibility lint":
+
+```rust
+FutureIncompatibleInfo {
+    id: LintId::of(OVERLAPPING_INHERENT_IMPLS),
+    reference: "issue #36889 <https://github.com/rust-lang/rust/issues/36889>",
+},
+```
+
+Remove this too.
+
+#### Add the lint to the list of removed lists.
+
+In `compiler/rustc_lint/src/lib.rs` there is a list of "renamed and removed lints".
+You can add this lint to the list:
+
+```rust
+store.register_removed("overlapping_inherent_impls", "converted into hard error, see #36889");
+```
+
+where `#36889` is the tracking issue for your lint.
+
+#### Update the places that issue the lint
+
+Finally, the last class of references you will see are the places that actually
+**trigger** the lint itself (i.e., what causes the warnings to appear). These
+you do not want to delete. Instead, you want to convert them into errors. In
+this case, the [`add_lint` call][addlintsource] looks like this:
+
+```rust
+self.tcx.sess.add_lint(lint::builtin::OVERLAPPING_INHERENT_IMPLS,
+                       node_id,
+                       self.tcx.span_of_impl(item1).unwrap(),
+                       msg);
+```
+
+We want to convert this into an error. In some cases, there may be an
+existing error for this scenario. In others, we will need to allocate a
+fresh diagnostic code.  [Instructions for allocating a fresh diagnostic
+code can be found here.](./diagnostics/diagnostic-codes.md) You may want
+to mention in the extended description that the compiler behavior
+changed on this point, and include a reference to the tracking issue for
+the change.
+
+Let's say that we've adopted `E0592` as our code. Then we can change the
+`add_lint()` call above to something like:
+
+```rust
+struct_span_err!(self.tcx.sess, self.tcx.span_of_impl(item1).unwrap(), msg)
+    .emit();
+```
+
+#### Update tests
+
+Finally, run the test suite. These should be some tests that used to reference
+the `overlapping_inherent_impls` lint, those will need to be updated. In
+general, if the test used to have `#[deny(overlapping_inherent_impls)]`, that
+can just be removed.
+
+```
+./x.py test
+```
+
+#### All done!
+
+Open a PR. =)
+
+[addlintsource]: https://github.com/rust-lang/rust/blob/085d71c3efe453863739c1fb68fd9bd1beff214f/src/librustc_typeck/coherence/inherent.rs#L300-L303
+[futuresource]: https://github.com/rust-lang/rust/blob/085d71c3efe453863739c1fb68fd9bd1beff214f/src/librustc_lint/lib.rs#L202-L205
+
+<!-- -Links--------------------------------------------------------------------- -->
+
+[rfc 1122]: https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md
+[breaking-change-issue]: https://gist.github.com/nikomatsakis/631ec8b4af9a18b5d062d9d9b7d3d967
diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping.md b/src/doc/rustc-dev-guide/src/building/bootstrapping.md
new file mode 100644
index 000000000..fd54de20c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping.md
@@ -0,0 +1,415 @@
+# Bootstrapping the Compiler
+
+<!-- toc -->
+
+
+[*Bootstrapping*][boot] is the process of using a compiler to compile itself.
+More accurately, it means using an older compiler to compile a newer version
+of the same compiler.
+
+This raises a chicken-and-egg paradox: where did the first compiler come from?
+It must have been written in a different language. In Rust's case it was
+[written in OCaml][ocaml-compiler]. However it was abandoned long ago and the
+only way to build a modern version of rustc is a slightly less modern
+version.
+
+This is exactly how `x.py` works: it downloads the current beta release of
+rustc, then uses it to compile the new compiler.
+
+## Stages of bootstrapping
+
+Compiling `rustc` is done in stages.
+
+### Stage 0
+
+The stage0 compiler is usually the current _beta_ `rustc` compiler
+and its associated dynamic libraries,
+which `x.py` will download for you.
+(You can also configure `x.py` to use something else.)
+
+The stage0 compiler is then used only to compile `rustbuild`, `std`, and `rustc`.
+When compiling `rustc`, the stage0 compiler uses the freshly compiled `std`.
+There are two concepts at play here:
+a compiler (with its set of dependencies)
+and its 'target' or 'object' libraries (`std` and `rustc`).
+Both are staged, but in a staggered manner.
+
+### Stage 1
+
+The rustc source code is then compiled with the stage0 compiler to produce the stage1 compiler.
+
+### Stage 2
+
+We then rebuild our stage1 compiler with itself to produce the stage2 compiler.
+
+In theory, the stage1 compiler is functionally identical to the stage2 compiler,
+but in practice there are subtle differences.
+In particular, the stage1 compiler itself was built by stage0
+and hence not by the source in your working directory.
+This means that the symbol names used in the compiler source
+may not match the symbol names that would have been made by the stage1 compiler,
+which can cause problems for dynamic libraries and tests.
+
+The `stage2` compiler is the one distributed with `rustup` and all other install methods.
+However, it takes a very long time to build
+because one must first build the new compiler with an older compiler
+and then use that to build the new compiler with itself.
+For development, you usually only want the `stage1` compiler,
+which you can build with `./x.py build library`.
+See [Building the Compiler](./how-to-build-and-run.html#building-the-compiler).
+
+### Stage 3
+
+Stage 3 is optional. To sanity check our new compiler, we
+can build the libraries with the stage2 compiler. The result ought
+to be identical to before, unless something has broken.
+
+### Building the stages
+
+`x.py` tries to be helpful and pick the stage you most likely meant for each subcommand.
+These defaults are as follows:
+
+- `check`: `--stage 0`
+- `doc`: `--stage 0`
+- `build`: `--stage 1`
+- `test`: `--stage 1`
+- `dist`: `--stage 2`
+- `install`: `--stage 2`
+- `bench`: `--stage 2`
+
+You can always override the stage by passing `--stage N` explicitly.
+
+For more information about stages, [see below](#understanding-stages-of-bootstrap).
+
+## Complications of bootstrapping
+
+Since the build system uses the current beta compiler to build the stage-1
+bootstrapping compiler, the compiler source code can't use some features
+until they reach beta (because otherwise the beta compiler doesn't support
+them). On the other hand, for [compiler intrinsics][intrinsics] and internal
+features, the features _have_ to be used. Additionally, the compiler makes
+heavy use of nightly features (`#![feature(...)]`). How can we resolve this
+problem?
+
+There are two methods used:
+1. The build system sets `--cfg bootstrap` when building with `stage0`, so we
+can use `cfg(not(bootstrap))` to only use features when built with `stage1`.
+This is useful for e.g. features that were just stabilized, which require
+`#![feature(...)]` when built with `stage0`, but not for `stage1`.
+2. The build system sets `RUSTC_BOOTSTRAP=1`. This special variable means to
+_break the stability guarantees_ of rust: Allow using `#![feature(...)]` with
+a compiler that's not nightly. This should never be used except when
+bootstrapping the compiler.
+
+[boot]: https://en.wikipedia.org/wiki/Bootstrapping_(compilers)
+[intrinsics]: ../appendix/glossary.md#intrinsic
+[ocaml-compiler]: https://github.com/rust-lang/rust/tree/ef75860a0a72f79f97216f8aaa5b388d98da6480/src/boot
+
+## Contributing to bootstrap
+
+When you use the bootstrap system, you'll call it through `x.py`.
+However, most of the code lives in `src/bootstrap`.
+`bootstrap` has a difficult problem: it is written in Rust, but yet it is run
+before the Rust compiler is built! To work around this, there are two
+components of bootstrap: the main one written in rust, and `bootstrap.py`.
+`bootstrap.py` is what gets run by `x.py`. It takes care of downloading the
+`stage0` compiler, which will then build the bootstrap binary written in
+Rust.
+
+Because there are two separate codebases behind `x.py`, they need to
+be kept in sync. In particular, both `bootstrap.py` and the bootstrap binary
+parse `config.toml` and read the same command line arguments. `bootstrap.py`
+keeps these in sync by setting various environment variables, and the
+programs sometimes have to add arguments that are explicitly ignored, to be
+read by the other.
+
+### Adding a setting to config.toml
+
+This section is a work in progress. In the meantime, you can see an example
+contribution [here][bootstrap-build].
+
+[bootstrap-build]: https://github.com/rust-lang/rust/pull/71994
+
+## Understanding stages of bootstrap
+
+### Overview
+
+This is a detailed look into the separate bootstrap stages.
+
+The convention `x.py` uses is that:
+
+- A `--stage N` flag means to run the stage N compiler (`stageN/rustc`).
+- A "stage N artifact" is a build artifact that is _produced_ by the stage N compiler.
+- The stage N+1 compiler is assembled from stage N *artifacts*. This
+  process is called _uplifting_.
+
+#### Build artifacts
+
+Anything you can build with `x.py` is a _build artifact_.
+Build artifacts include, but are not limited to:
+
+- binaries, like `stage0-rustc/rustc-main`
+- shared objects, like `stage0-sysroot/rustlib/libstd-6fae108520cf72fe.so`
+- [rlib] files, like `stage0-sysroot/rustlib/libstd-6fae108520cf72fe.rlib`
+- HTML files generated by rustdoc, like `doc/std`
+
+[rlib]: ../serialization.md
+
+#### Examples
+
+- `./x.py build --stage 0` means to build with the beta `rustc`.
+- `./x.py doc --stage 0` means to document using the beta `rustdoc`.
+- `./x.py test --stage 0 library/std` means to run tests on the standard library
+    without building `rustc` from source ('build with stage 0, then test the
+  artifacts'). If you're working on the standard library, this is normally the
+  test command you want.
+- `./x.py test src/test/ui` means to build the stage 1 compiler and run
+  `compiletest` on it. If you're working on the compiler, this is normally the
+  test command you want.
+
+#### Examples of what *not* to do
+
+- `./x.py test --stage 0 src/test/ui` is not useful: it runs tests on the
+  _beta_ compiler and doesn't build `rustc` from source. Use `test src/test/ui`
+  instead, which builds stage 1 from source.
+- `./x.py test --stage 0 compiler/rustc` builds the compiler but runs no tests:
+  it's running `cargo test -p rustc`, but cargo doesn't understand Rust's
+  tests. You shouldn't need to use this, use `test` instead (without arguments).
+- `./x.py build --stage 0 compiler/rustc` builds the compiler, but does not build
+  libstd or even libcore. Most of the time, you'll want `./x.py build
+  library` instead, which allows compiling programs without needing to define
+  lang items.
+
+### Building vs. running
+
+Note that `build --stage N compiler/rustc` **does not** build the stage N compiler:
+instead it builds the stage N+1 compiler _using_ the stage N compiler.
+
+In short, _stage 0 uses the stage0 compiler to create stage0 artifacts which
+will later be uplifted to be the stage1 compiler_.
+
+In each stage, two major steps are performed:
+
+1. `std` is compiled by the stage N compiler.
+2. That `std` is linked to programs built by the stage N compiler,
+   including the stage N artifacts (stage N+1 compiler).
+
+This is somewhat intuitive if one thinks of the stage N artifacts as "just"
+another program we are building with the stage N compiler:
+`build --stage N compiler/rustc` is linking the stage N artifacts to the `std`
+built by the stage N compiler.
+
+Here is a chart of a full build using `x.py`:
+
+<img alt="A diagram of the rustc compilation phases" src="../img/rustc_stages.svg" class="center" />
+
+Keep in mind this diagram is a simplification, i.e. `rustdoc` can be built at
+different stages, the process is a bit different when passing flags such as
+`--keep-stage`, or if there are non-host targets.
+
+### Stages and `std`
+
+Note that there are two `std` libraries in play here:
+1. The library _linked_ to `stageN/rustc`, which was built by stage N-1 (stage N-1 `std`)
+2. The library _used to compile programs_ with `stageN/rustc`, which was
+   built by stage N (stage N `std`).
+
+Stage N `std` is pretty much necessary for any useful work with the stage N compiler.
+Without it, you can only compile programs with `#![no_core]` -- not terribly useful!
+
+The reason these need to be different is because they aren't necessarily ABI-compatible:
+there could be new layout optimizations, changes to MIR, or other changes
+to Rust metadata on nightly that aren't present in beta.
+
+This is also where `--keep-stage 1 library/std` comes into play. Since most
+changes to the compiler don't actually change the ABI, once you've produced a
+`std` in stage 1, you can probably just reuse it with a different compiler.
+If the ABI hasn't changed, you're good to go, no need to spend time
+recompiling that `std`.
+`--keep-stage` simply assumes the previous compile is fine and copies those
+artifacts into the appropriate place, skipping the cargo invocation.
+
+### Cross-compiling rustc
+
+*Cross-compiling* is the process of compiling code that will run on another architecture.
+For instance, you might want to build an ARM version of rustc using an x86 machine.
+Building stage2 `std` is different when you are cross-compiling.
+
+This is because `x.py` uses a trick: if `HOST` and `TARGET` are the same,
+it will reuse stage1 `std` for stage2! This is sound because stage1 `std`
+was compiled with the stage1 compiler, i.e. a compiler using the source code
+you currently have checked out. So it should be identical (and therefore ABI-compatible)
+to the `std` that `stage2/rustc` would compile.
+
+However, when cross-compiling, stage1 `std` will only run on the host.
+So the stage2 compiler has to recompile `std` for the target.
+
+(See in the table how stage2 only builds non-host `std` targets).
+
+### Why does only libstd use `cfg(bootstrap)`?
+
+The `rustc` generated by the stage0 compiler is linked to the freshly-built
+`std`, which means that for the most part only `std` needs to be cfg-gated,
+so that `rustc` can use features added to std immediately after their addition,
+without need for them to get into the downloaded beta.
+
+Note this is different from any other Rust program: stage1 `rustc`
+is built by the _beta_ compiler, but using the _master_ version of libstd!
+
+The only time `rustc` uses `cfg(bootstrap)` is when it adds internal lints
+that use diagnostic items. This happens very rarely.
+
+### What is a 'sysroot'?
+
+When you build a project with cargo, the build artifacts for dependencies
+are normally stored in `target/debug/deps`. This only contains dependencies cargo
+knows about; in particular, it doesn't have the standard library. Where do
+`std` or `proc_macro` come from? It comes from the **sysroot**, the root
+of a number of directories where the compiler loads build artifacts at runtime.
+The sysroot doesn't just store the standard library, though - it includes
+anything that needs to be loaded at runtime. That includes (but is not limited
+to):
+
+- `libstd`/`libtest`/`libproc_macro`
+- The compiler crates themselves, when using `rustc_private`. In-tree these
+  are always present; out of tree, you need to install `rustc-dev` with rustup.
+- `libLLVM.so`, the shared object file for the LLVM project. In-tree this is
+  either built from source or downloaded from CI; out-of-tree, you need to
+  install `llvm-tools-preview` with rustup.
+
+All the artifacts listed so far are *compiler* runtime dependencies. You can
+see them with `rustc --print sysroot`:
+
+```
+$ ls $(rustc --print sysroot)/lib
+libchalk_derive-0685d79833dc9b2b.so  libstd-25c6acf8063a3802.so
+libLLVM-11-rust-1.50.0-nightly.so    libtest-57470d2aa8f7aa83.so
+librustc_driver-4f0cc9f50e53f0ba.so  libtracing_attributes-e4be92c35ab2a33b.so
+librustc_macros-5f0ec4a119c6ac86.so  rustlib
+```
+
+There are also runtime dependencies for the standard library! These are in
+`lib/rustlib`, not `lib/` directly.
+
+```
+$ ls $(rustc --print sysroot)/lib/rustlib/x86_64-unknown-linux-gnu/lib | head -n 5
+libaddr2line-6c8e02b8fedc1e5f.rlib
+libadler-9ef2480568df55af.rlib
+liballoc-9c4002b5f79ba0e1.rlib
+libcfg_if-512eb53291f6de7e.rlib
+libcompiler_builtins-ef2408da76957905.rlib
+```
+
+`rustlib` includes libraries like `hashbrown` and `cfg_if`, which are not part
+of the public API of the standard library, but are used to implement it.
+`rustlib` is part of the search path for linkers, but `lib` will never be part
+of the search path.
+
+#### -Z force-unstable-if-unmarked
+
+Since `rustlib` is part of the search path, it means we have to be careful
+about which crates are included in it. In particular, all crates except for
+the standard library are built with the flag `-Z force-unstable-if-unmarked`,
+which means that you have to use `#![feature(rustc_private)]` in order to
+load it (as opposed to the standard library, which is always available).
+
+The `-Z force-unstable-if-unmarked` flag has a variety of purposes to help
+enforce that the correct crates are marked as unstable. It was introduced
+primarily to allow rustc and the standard library to link to arbitrary crates
+on crates.io which do not themselves use `staged_api`. `rustc` also relies on
+this flag to mark all of its crates as unstable with the `rustc_private`
+feature so that each crate does not need to be carefully marked with
+`unstable`.
+
+This flag is automatically applied to all of `rustc` and the standard library
+by the bootstrap scripts. This is needed because the compiler and all of its
+dependencies are shipped in the sysroot to all users.
+
+This flag has the following effects:
+
+- Marks the crate as "unstable" with the `rustc_private` feature if it is not
+  itself marked as stable or unstable.
+- Allows these crates to access other forced-unstable crates without any need
+  for attributes. Normally a crate would need a `#![feature(rustc_private)]`
+  attribute to use other unstable crates. However, that would make it
+  impossible for a crate from crates.io to access its own dependencies since
+  that crate won't have a `feature(rustc_private)` attribute, but *everything*
+  is compiled with `-Z force-unstable-if-unmarked`.
+
+Code which does not use `-Z force-unstable-if-unmarked` should include the
+`#![feature(rustc_private)]` crate attribute to access these force-unstable
+crates. This is needed for things that link `rustc`, such as `miri`, `rls`, or
+`clippy`.
+
+You can find more discussion about sysroots in:
+- The [rustdoc PR] explaining why it uses `extern crate` for dependencies loaded from sysroot
+- [Discussions about sysroot on Zulip](https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/deps.20in.20sysroot/)
+- [Discussions about building rustdoc out of tree](https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/How.20to.20create.20an.20executable.20accessing.20.60rustc_private.60.3F)
+
+[rustdoc PR]: https://github.com/rust-lang/rust/pull/76728
+
+### Directories and artifacts generated by `x.py`
+
+The following tables indicate the outputs of various stage actions:
+
+| Stage 0 Action                                            | Output                                       |
+|-----------------------------------------------------------|----------------------------------------------|
+| `beta` extracted                                          | `build/HOST/stage0`                          |
+| `stage0` builds `bootstrap`                               | `build/bootstrap`                            |
+| `stage0` builds `test`/`std`                              | `build/HOST/stage0-std/TARGET`               |
+| copy `stage0-std` (HOST only)                             | `build/HOST/stage0-sysroot/lib/rustlib/HOST` |
+| `stage0` builds `rustc` with `stage0-sysroot`             | `build/HOST/stage0-rustc/HOST`               |
+| copy `stage0-rustc` (except executable)                   | `build/HOST/stage0-sysroot/lib/rustlib/HOST` |
+| build `llvm`                                              | `build/HOST/llvm`                            |
+| `stage0` builds `codegen` with `stage0-sysroot`           | `build/HOST/stage0-codegen/HOST`             |
+| `stage0` builds `rustdoc`, `clippy`, `miri`, with `stage0-sysroot` | `build/HOST/stage0-tools/HOST`      |
+
+`--stage=0` stops here.
+
+| Stage 1 Action                                      | Output                                |
+|-----------------------------------------------------|---------------------------------------|
+| copy (uplift) `stage0-rustc` executable to `stage1` | `build/HOST/stage1/bin`               |
+| copy (uplift) `stage0-codegen` to `stage1`          | `build/HOST/stage1/lib`               |
+| copy (uplift) `stage0-sysroot` to `stage1`          | `build/HOST/stage1/lib`               |
+| `stage1` builds `test`/`std`                        | `build/HOST/stage1-std/TARGET`        |
+| copy `stage1-std` (HOST only)                       | `build/HOST/stage1/lib/rustlib/HOST`  |
+| `stage1` builds `rustc`                             | `build/HOST/stage1-rustc/HOST`        |
+| copy `stage1-rustc` (except executable)             | `build/HOST/stage1/lib/rustlib/HOST`  |
+| `stage1` builds `codegen`                           | `build/HOST/stage1-codegen/HOST`      |
+
+`--stage=1` stops here.
+
+| Stage 2 Action                                         | Output                                                          |
+|--------------------------------------------------------|-----------------------------------------------------------------|
+| copy (uplift) `stage1-rustc` executable                | `build/HOST/stage2/bin`                                         |
+| copy (uplift) `stage1-sysroot`                         | `build/HOST/stage2/lib and build/HOST/stage2/lib/rustlib/HOST`  |
+| `stage2` builds `test`/`std` (not HOST targets)        | `build/HOST/stage2-std/TARGET`                                  |
+| copy `stage2-std` (not HOST targets)                   | `build/HOST/stage2/lib/rustlib/TARGET`                          |
+| `stage2` builds `rustdoc`, `clippy`, `miri`            | `build/HOST/stage2-tools/HOST`                                  |
+| copy `rustdoc`                                         | `build/HOST/stage2/bin`                                         |
+
+`--stage=2` stops here.
+
+## Passing stage-specific flags to `rustc`
+
+`x.py` allows you to pass stage-specific flags to `rustc` when bootstrapping.
+The `RUSTFLAGS_BOOTSTRAP` environment variable is passed as RUSTFLAGS to the bootstrap stage
+(stage0), and `RUSTFLAGS_NOT_BOOTSTRAP` is passed when building artifacts for later stages.
+
+## Environment Variables
+
+During bootstrapping, there are a bunch of compiler-internal environment
+variables that are used. If you are trying to run an intermediate version of
+`rustc`, sometimes you may need to set some of these environment variables
+manually. Otherwise, you get an error like the following:
+
+```text
+thread 'main' panicked at 'RUSTC_STAGE was not set: NotPresent', library/core/src/result.rs:1165:5
+```
+
+If `./stageN/bin/rustc` gives an error about environment variables, that
+usually means something is quite wrong -- or you're trying to compile e.g.
+`rustc` or `std` or something that depends on environment variables. In
+the unlikely case that you actually need to invoke rustc in such a situation,
+you can find the environment variable values by adding the following flag to
+your `x.py` command: `--on-fail=print-env`.
diff --git a/src/doc/rustc-dev-guide/src/building/build-install-distribution-artifacts.md b/src/doc/rustc-dev-guide/src/building/build-install-distribution-artifacts.md
new file mode 100644
index 000000000..4ec3f958a
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/build-install-distribution-artifacts.md
@@ -0,0 +1,29 @@
+# Build distribution artifacts
+
+You might want to build and package up the compiler for distribution.
+You’ll want to run this command to do it:
+
+   ```bash
+   ./x.py dist
+   ```
+
+# Install distribution artifacts
+
+If you’ve built a distribution artifact you might want to install it and
+test that it works on your target system. You’ll want to run this command:
+
+   ```bash
+   ./x.py install
+   ```
+
+   Note: If you are testing out a modification to a compiler, you
+   might want to use it to compile some project.
+   Usually, you do not want to use `./x.py install` for testing.
+   Rather, you should create a toolchain as discussed in
+   [here][create-rustup-toolchain].
+
+   For example, if the toolchain you created is called foo, you
+   would then invoke it with `rustc +foo ...` (where ... represents
+   the rest of the arguments).
+
+[create-rustup-toolchain]: ./how-to-build-and-run.md#creating-a-rustup-toolchain
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/building/compiler-documenting.md b/src/doc/rustc-dev-guide/src/building/compiler-documenting.md
new file mode 100644
index 000000000..965e004c9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/compiler-documenting.md
@@ -0,0 +1,49 @@
+# Building documentation
+
+This chapter describes how to build documentation of toolchain components,
+like the standard library (std) or the compiler (rustc).
+
+- Document everything
+
+  This uses `rustdoc` from the beta toolchain,
+  so will produce (slightly) different output to stage 1 rustdoc,
+  as rustdoc is under active development:
+
+  ```bash
+  ./x.py doc
+  ```
+
+  If you want to be sure the documentation looks the same as on CI:
+
+  ```bash
+  ./x.py doc --stage 1
+  ```
+
+  This ensures that (current) rustdoc gets built,
+  then that is used to document the components.
+
+- Much like running individual tests or building specific components,
+  you can build just the documentation you want:
+
+  ```bash
+  ./x.py doc src/doc/book
+  ./x.py doc src/doc/nomicon
+  ./x.py doc compiler library
+  ```
+
+- Document internal rustc items
+
+  Compiler documentation is not built by default.
+  To create it by default with `x.py doc`, modify `config.toml`:
+
+  ```toml
+  [build]
+  compiler-docs = true
+  ```
+
+  Note that when enabled,
+  documentation for internal compiler items will also be built.
+
+  NOTE: The documentation for the compiler is found at [this link].
+
+[this link]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/
diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
new file mode 100644
index 000000000..cce9d766a
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -0,0 +1,298 @@
+# How to Build and Run the Compiler
+
+The compiler is built using a tool called `x.py`. You will need to
+have Python installed to run it.
+
+For instructions on how to install Python and other prerequisites,
+see [the next page](./prerequisites.md).
+
+## Get the source code
+
+The main repository is [`rust-lang/rust`][repo]. This contains the compiler,
+the standard library (including `core`, `alloc`, `test`, `proc_macro`, etc),
+and a bunch of tools (e.g. `rustdoc`, the bootstrapping infrastructure, etc).
+
+[repo]: https://github.com/rust-lang/rust
+
+The very first step to work on `rustc` is to clone the repository:
+
+```bash
+git clone https://github.com/rust-lang/rust.git
+cd rust
+```
+
+There are also submodules for things like LLVM, `clippy`, `miri`, etc. The
+build tool will automatically clone and sync these for you. But if you want to,
+you can do the following:
+
+```sh
+# first time
+git submodule update --init --recursive
+
+# subsequent times (to pull new commits)
+git submodule update
+```
+
+## Create a `config.toml`
+
+To start, run `./x.py setup`. This will do some initialization and create a
+`config.toml` for you with reasonable defaults. These defaults are specified
+indirectly via the `profile` setting, which points to one of the TOML files in
+`src/bootstrap/defaults.`
+
+Alternatively, you can write `config.toml` by hand. See `config.toml.example`
+for all the available settings and explanations of them. The following settings
+are of particular interest, and `config.toml.example` has full explanations.
+
+You may want to change some of the following settings (and possibly others, such as
+`llvm.ccache`):
+
+```toml
+[llvm]
+# Whether to use Rust CI built LLVM instead of locally building it.
+download-ci-llvm = true     # Download a pre-built LLVM?
+assertions = true           # LLVM assertions on?
+ccache = "/path/to/ccache"  # Use ccache when building LLVM?
+
+[rust]
+debug-logging = true        # Leave debug! and trace! calls in rustc?
+incremental = true          # Build rustc with incremental compilation?
+```
+
+If you set `download-ci-llvm = true`, in some circumstances, such as when
+updating the version of LLVM used by `rustc`, you may want to temporarily
+disable this feature. See the ["Updating LLVM" section] for more.
+
+["Updating LLVM" section]: ../backend/updating-llvm.md#feature-updates
+
+If you have already built `rustc` and you change settings related to LLVM, then you may have to
+execute `rm -rf build` for subsequent configuration changes to take effect. Note that `./x.py
+clean` will not cause a rebuild of LLVM.
+
+## What is `x.py`?
+
+`x.py` is the script used to orchestrate the tooling in the `rustc` repository.
+It is the script that can build docs, run tests, and compile `rustc`.
+It is the now preferred way to build `rustc` and it replaces the old makefiles
+from before. Below are the different ways to utilize `x.py` in order to
+effectively deal with the repo for various common tasks.
+
+This chapter focuses on the basics to be productive, but
+if you want to learn more about `x.py`, read its README.md
+[here](https://github.com/rust-lang/rust/blob/master/src/bootstrap/README.md).
+To read more about the bootstrap process and why `x.py` is necessary,
+[read this chapter][bootstrap].
+
+### Running `x.py` slightly more conveniently
+
+There is a binary that wraps `x.py` called `x` in `src/tools/x`. All it does is
+run `x.py`, but it can be installed system-wide and run from any subdirectory
+of a checkout. It also looks up the appropriate version of `python` to use.
+
+You can install it with `cargo install --path src/tools/x`.
+
+[bootstrap]: ./bootstrapping.md
+
+## Building the Compiler
+
+To build a compiler, run `./x.py build`. This will build up to the stage1 compiler,
+including `rustdoc`, producing a usable compiler toolchain from the source
+code you have checked out.
+
+Note that building will require a relatively large amount of storage space.
+You may want to have upwards of 10 or 15 gigabytes available to build the compiler.
+
+There are many flags you can pass to the build command of `x.py` that can be
+beneficial to cutting down compile times or fitting other things you might
+need to change. They are:
+
+```txt
+Options:
+    -v, --verbose       use verbose output (-vv for very verbose)
+    -i, --incremental   use incremental compilation
+        --config FILE   TOML configuration file for build
+        --build BUILD   build target of the stage0 compiler
+        --host HOST     host targets to build
+        --target TARGET target targets to build
+        --on-fail CMD   command to run on failure
+        --stage N       stage to build
+        --keep-stage N  stage to keep without recompiling
+        --src DIR       path to the root of the Rust checkout
+    -j, --jobs JOBS     number of jobs to run in parallel
+    -h, --help          print this help message
+```
+
+For hacking, often building the stage 1 compiler is enough, which saves a lot
+of time. But for final testing and release, the stage 2 compiler is used.
+
+`./x.py check` is really fast to build the Rust compiler.
+It is, in particular, very useful when you're doing some kind of
+"type-based refactoring", like renaming a method, or changing the
+signature of some function.
+
+Once you've created a `config.toml`, you are now ready to run
+`x.py`. There are a lot of options here, but let's start with what is
+probably the best "go to" command for building a local rust:
+
+```bash
+./x.py build library
+```
+
+This may *look* like it only builds the standard library, but that is not the case.
+What this command does is the following:
+
+- Build `std` using the stage0 compiler
+- Build `rustc` using the stage0 compiler
+  - This produces the stage1 compiler
+- Build `std` using the stage1 compiler
+
+This final product (stage1 compiler + libs built using that compiler)
+is what you need to build other Rust programs (unless you use `#![no_std]` or
+`#![no_core]`).
+
+You will probably find that building the stage1 `std` is a bottleneck for you** -- but fear not,
+there is a (hacky) workaround. See [the section on "recommended workflows"](./suggested.md) below.
+
+Note that this whole command just gives you a subset of the full `rustc`
+build. The **full** `rustc` build (what you get with `./x.py build
+--stage 2 compiler/rustc`) has quite a few more steps:
+
+- Build `rustc` with the stage1 compiler.
+  - The resulting compiler here is called the "stage2" compiler.
+- Build `std` with stage2 compiler.
+- Build `librustdoc` and a bunch of other things with the stage2 compiler.
+
+You almost never need to do this.
+
+## Build specific components
+
+If you are working on the standard library, you probably don't need to build
+the compiler unless you are planning to use a recently added nightly feature.
+Instead, you can just build using the bootstrap compiler.
+
+```bash
+./x.py build --stage 0 library
+```
+
+## Creating a rustup toolchain
+
+Once you have successfully built `rustc`, you will have created a bunch
+of files in your `build` directory. In order to actually run the
+resulting `rustc`, we recommend creating rustup toolchains. The first
+one will run the stage1 compiler (which we built above). The second
+will execute the stage2 compiler (which we did not build, but which
+you will likely need to build at some point; for example, if you want
+to run the entire test suite).
+
+```bash
+rustup toolchain link stage1 build/<host-triple>/stage1
+rustup toolchain link stage2 build/<host-triple>/stage2
+```
+
+The `<host-triple>` would typically be one of the following:
+
+- Linux: `x86_64-unknown-linux-gnu`
+- Mac: `x86_64-apple-darwin` or `aarch64-apple-darwin`
+- Windows: `x86_64-pc-windows-msvc`
+
+Now you can run the `rustc` you built with. If you run with `-vV`, you
+should see a version number ending in `-dev`, indicating a build from
+your local environment:
+
+```bash
+$ rustc +stage1 -vV
+rustc 1.48.0-dev
+binary: rustc
+commit-hash: unknown
+commit-date: unknown
+host: x86_64-unknown-linux-gnu
+release: 1.48.0-dev
+LLVM version: 11.0
+```
+
+The rustup toolchain points to the specified toolchain compiled in your `build` directory,
+so the rustup toolchain will be updated whenever `x.py build` or `x.py test` are run for
+that toolchain/stage.
+
+**Note:** the toolchain we've built does not include `cargo`.  In this case, `rustup` will
+fall back to using `cargo` from the installed `nightly`, `beta`, or `stable` toolchain
+(in that order).  If you need to use unstable `cargo` flags, be sure to run
+`rustup install nightly` if you haven't already.  See the
+[rustup documentation on custom toolchains](https://rust-lang.github.io/rustup/concepts/toolchains.html#custom-toolchains).
+
+## Building targets for cross-compilation
+
+To produce a compiler that can cross-compile for other targets,
+pass any number of `target` flags to `x.py build`.
+For example, if your host platform is `x86_64-unknown-linux-gnu`
+and your cross-compilation target is `wasm32-wasi`, you can build with:
+
+```bash
+./x.py build --target x86_64-unknown-linux-gnu --target wasm32-wasi
+```
+
+Note that if you want the resulting compiler to be able to build crates that
+involve proc macros or build scripts, you must be sure to explicitly build target support for the
+host platform (in this case, `x86_64-unknown-linux-gnu`).
+
+If you want to always build for other targets without needing to pass flags to `x.py build`,
+you can configure this in the `[build]` section of your `config.toml` like so:
+
+```toml
+[build]
+target = ["x86_64-unknown-linux-gnu", "wasm32-wasi"]
+```
+
+Note that building for some targets requires having external dependencies installed
+(e.g. building musl targets requires a local copy of musl).
+Any target-specific configuration (e.g. the path to a local copy of musl)
+will need to be provided by your `config.toml`.
+Please see `config.toml.example` for information on target-specific configuration keys.
+
+For examples of the complete configuration necessary to build a target, please visit
+[the rustc book](https://doc.rust-lang.org/rustc/platform-support.html),
+select any target under the "Platform Support" heading on the left,
+and see the section related to building a compiler for that target.
+For targets without a corresponding page in the rustc book,
+it may be useful to [inspect the Dockerfiles](../tests/docker.md)
+that the Rust infrastructure itself uses to set up and configure cross-compilation.
+
+If you have followed the directions from the prior section on creating a rustup toolchain,
+then once you have built your compiler you will be able to use it to cross-compile like so:
+
+```bash
+cargo +stage1 build --target wasm32-wasi
+```
+
+## Other `x.py` commands
+
+Here are a few other useful `x.py` commands. We'll cover some of them in detail
+in other sections:
+
+- Building things:
+  - `./x.py build` – builds everything using the stage 1 compiler,
+    not just up to `std`
+  - `./x.py build --stage 2` – builds everything with the stage 2 compiler including
+    `rustdoc` (which doesn't take too long)
+- Running tests (see the [section on running tests](../tests/running.html) for
+  more details):
+  - `./x.py test library/std` – runs the unit tests and integration tests from `std`
+  - `./x.py test src/test/ui` – runs the `ui` test suite
+  - `./x.py test src/test/ui/const-generics` - runs all the tests in
+  the `const-generics/` subdirectory of the `ui` test suite
+  - `./x.py test src/test/ui/const-generics/const-types.rs` - runs
+  the single test `const-types.rs` from the `ui` test suite
+
+### Cleaning out build directories
+
+Sometimes you need to start fresh, but this is normally not the case.
+If you need to run this then `rustbuild` is most likely not acting right and
+you should file a bug as to what is going wrong. If you do need to clean
+everything up then you only need to run one command!
+
+```bash
+./x.py clean
+```
+
+`rm -rf build` works too, but then you have to rebuild LLVM, which can take
+a long time even on fast computers.
diff --git a/src/doc/rustc-dev-guide/src/building/new-target.md b/src/doc/rustc-dev-guide/src/building/new-target.md
new file mode 100644
index 000000000..77833fad1
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/new-target.md
@@ -0,0 +1,156 @@
+# Adding a new target
+
+These are a set of steps to add support for a new target. There are
+numerous end states and paths to get there, so not all sections may be
+relevant to your desired goal.
+
+## Specifying a new LLVM
+
+For very new targets, you may need to use a different fork of LLVM
+than what is currently shipped with Rust. In that case, navigate to
+the `src/llvm-project` git submodule (you might need to run `./x.py
+check` at least once so the submodule is updated), check out the
+appropriate commit for your fork, then commit that new submodule
+reference in the main Rust repository.
+
+An example would be:
+
+```
+cd src/llvm-project
+git remote add my-target-llvm some-llvm-repository
+git checkout my-target-llvm/my-branch
+cd ..
+git add llvm-project
+git commit -m 'Use my custom LLVM'
+```
+
+### Using pre-built LLVM
+
+If you have a local LLVM checkout that is already built, you may be
+able to configure Rust to treat your build as the system LLVM to avoid
+redundant builds.
+
+You can tell Rust to use a pre-built version of LLVM using the `target` section
+of `config.toml`:
+
+```toml
+[target.x86_64-unknown-linux-gnu]
+llvm-config = "/path/to/llvm/llvm-7.0.1/bin/llvm-config"
+```
+
+If you are attempting to use a system LLVM, we have observed the following paths
+before, though they may be different from your system:
+
+- `/usr/bin/llvm-config-8`
+- `/usr/lib/llvm-8/bin/llvm-config`
+
+Note that you need to have the LLVM `FileCheck` tool installed, which is used
+for codegen tests. This tool is normally built with LLVM, but if you use your
+own preinstalled LLVM, you will need to provide `FileCheck` in some other way.
+On Debian-based systems, you can install the `llvm-N-tools` package (where `N`
+is the LLVM version number, e.g. `llvm-8-tools`). Alternately, you can specify
+the path to `FileCheck` with the `llvm-filecheck` config item in `config.toml`
+or you can disable codegen test with the `codegen-tests` item in `config.toml`.
+
+## Creating a target specification
+
+You should start with a target JSON file. You can see the specification
+for an existing target using `--print target-spec-json`:
+
+```
+rustc -Z unstable-options --target=wasm32-unknown-unknown --print target-spec-json
+```
+
+Save that JSON to a file and modify it as appropriate for your target.
+
+### Adding a target specification
+
+Once you have filled out a JSON specification and been able to compile
+somewhat successfully, you can copy the specification into the
+compiler itself.
+
+You will need to add a line to the big table inside of the
+`supported_targets` macro in the `rustc_target::spec` module. You
+will then add a corresponding file for your new target containing a
+`target` function.
+
+Look for existing targets to use as examples.
+
+After adding your target to the `rustc_target` crate you may want to add
+`core`, `std`, ... with support for your new target. In that case you will
+probably need access to some `target_*` cfg. Unfortunately when building with
+stage0 (the beta compiler), you'll get an error that the target cfg is
+unexpected because stage0 doesn't know about the new target specification and
+we pass `--check-cfg` in order to tell it to check.
+
+To fix the errors you will need to manually add the unexpected value to the
+`EXTRA_CHECK_CFGS` list in `src/bootstrap/lib.rs`. Here is an example for
+adding `NEW_TARGET_OS` as `target_os`:
+```diff
+- (Some(Mode::Std), "target_os", Some(&["watchos"])),
++ // #[cfg(bootstrap)] NEW_TARGET_OS
++ (Some(Mode::Std), "target_os", Some(&["watchos", "NEW_TARGET_OS"])),
+```
+
+## Patching crates
+
+You may need to make changes to crates that the compiler depends on,
+such as [`libc`][] or [`cc`][]. If so, you can use Cargo's
+[`[patch]`][patch] ability. For example, if you want to use an
+unreleased version of `libc`, you can add it to the top-level
+`Cargo.toml` file:
+
+```diff
+diff --git a/Cargo.toml b/Cargo.toml
+index be15e50e2bc..4fb1248ba99 100644
+--- a/Cargo.toml
++++ b/Cargo.toml
+@@ -66,10 +66,11 @@ cargo = { path = "src/tools/cargo" }
+ [patch.crates-io]
+ # Similar to Cargo above we want the RLS to use a vendored version of `rustfmt`
+ # that we're shipping as well (to ensure that the rustfmt in RLS and the
+ # `rustfmt` executable are the same exact version).
+ rustfmt-nightly = { path = "src/tools/rustfmt" }
++libc = { git = "https://github.com/rust-lang/libc", rev = "0bf7ce340699dcbacabdf5f16a242d2219a49ee0" }
+
+ # See comments in `src/tools/rustc-workspace-hack/README.md` for what's going on
+ # here
+ rustc-workspace-hack = { path = 'src/tools/rustc-workspace-hack' }
+```
+
+After this, run `cargo update -p libc` to update the lockfiles.
+
+Beware that if you patch to a local `path` dependency, this will enable
+warnings for that dependency. Some dependencies are not warning-free, and due
+to the `deny-warnings` setting in `config.toml`, the build may suddenly start
+to fail. To work around the warnings, you may want to disable `deny-warnings`
+in the config, or modify the dependency to remove the warnings.
+
+[`libc`]: https://crates.io/crates/libc
+[`cc`]: https://crates.io/crates/cc
+[patch]: https://doc.rust-lang.org/stable/cargo/reference/overriding-dependencies.html#the-patch-section
+
+## Cross-compiling
+
+Once you have a target specification in JSON and in the code, you can
+cross-compile `rustc`:
+
+```
+DESTDIR=/path/to/install/in \
+./x.py install -i --stage 1 --host aarch64-apple-darwin.json --target aarch64-apple-darwin \
+compiler/rustc library/std
+```
+
+If your target specification is already available in the bootstrap
+compiler, you can use it instead of the JSON file for both arguments.
+
+## Promoting a target from tier 2 (target) to tier 2 (host)
+
+There are two levels of tier 2 targets:
+  a) Targets that are only cross-compiled (`rustup target add`)
+  b) Targets that [have a native toolchain][tier2-native] (`rustup toolchain install`)
+
+[tier2-native]: https://doc.rust-lang.org/nightly/rustc/target-tier-policy.html#tier-2-with-host-tools
+
+For an example of promoting a target from cross-compiled to native,
+see [#75914](https://github.com/rust-lang/rust/pull/75914).
diff --git a/src/doc/rustc-dev-guide/src/building/prerequisites.md b/src/doc/rustc-dev-guide/src/building/prerequisites.md
new file mode 100644
index 000000000..a5ab23d91
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/prerequisites.md
@@ -0,0 +1,85 @@
+# Prerequisites
+
+## Dependencies
+
+Before building the compiler, you need the following things installed:
+
+* `python` 3 or 2.7 (under the name `python`; `python2` or `python3` will not work)
+* `curl`
+* `git`
+* `ssl` which comes in `libssl-dev` or `openssl-devel`
+* `pkg-config` if you are compiling on Linux and targeting Linux
+
+If building LLVM from source (the default), you'll need additional tools:
+
+* `g++` 5.1 or later, `clang++` 3.5 or later, or MSVC 2017 or later.
+* `ninja`, or GNU `make` 3.81 or later (ninja is recommended, especially on Windows)
+* `cmake` 3.13.4 or later
+
+Otherwise, you'll need LLVM installed and `llvm-config` in your path.
+See [this section for more info][sysllvm].
+
+[sysllvm]: ./new-target.md#using-pre-built-llvm
+
+### Windows
+
+* Install [winget](https://github.com/microsoft/winget-cli)
+
+`winget` is a Windows package manager. It will make package installation easy
+on Windows.
+
+Run the following in a terminal:
+
+```powershell
+winget install -e Python.Python.3
+winget install -e Kitware.CMake
+```
+
+If any of those is installed already, winget will detect it.
+Then edit your systems `PATH` variable and add: `C:\Program Files\CMake\bin`.
+
+For more information about building on Windows,
+see [the `rust-lang/rust` README](https://github.com/rust-lang/rust#building-on-windows).
+
+## Hardware
+
+You will need an internet connection to build. The bootstrapping process
+involves updating git submodules and downloading a beta compiler. It doesn't
+need to be super fast, but that can help.
+
+There are no strict hardware requirements, but building the compiler is
+computationally expensive, so a beefier machine will help, and I wouldn't
+recommend trying to build on a Raspberry Pi! We recommend the following.
+* 30GB+ of free disk space. Otherwise, you will have to keep
+  clearing incremental caches. More space is better, the compiler is a bit of a
+  hog; it's a problem we are aware of.
+* 8GB+ RAM
+* 2+ cores. Having more cores really helps. 10 or 20 or more is not too many!
+
+Beefier machines will lead to much faster builds. If your machine is not very
+powerful, a common strategy is to only use `./x.py check` on your local machine
+and let the CI build test your changes when you push to a PR branch.
+
+Building the compiler takes more than half an hour on my moderately powerful
+laptop. The first time you build the compiler, LLVM will also be built unless
+you use CI-built LLVM ([see here][config]).
+
+Like `cargo`, the build system will use as many cores as possible. Sometimes
+this can cause you to run low on memory. You can use `-j` to adjust the number
+concurrent jobs. If a full build takes more than ~45 minutes to an hour, you
+are probably spending most of the time swapping memory in and out; try using
+`-j1`.
+
+If you don't have too much free disk space, you may want to turn off
+incremental compilation ([see here][config]). This will make compilation take
+longer (especially after a rebase), but will save a ton of space from the
+incremental caches.
+
+[config]: ./how-to-build-and-run.md#create-a-configtoml
+
+## `rustc` and toolchain installation
+
+Follow the installation given in the [Rust book][install] to install a working
+`rustc` and the necessary C/++ toolchain on your platform.
+
+[install]: https://doc.rust-lang.org/book/ch01-01-installation.html
diff --git a/src/doc/rustc-dev-guide/src/building/suggested.md b/src/doc/rustc-dev-guide/src/building/suggested.md
new file mode 100644
index 000000000..1c2229335
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/building/suggested.md
@@ -0,0 +1,298 @@
+# Suggested Workflows
+
+The full bootstrapping process takes quite a while. Here are some suggestions
+to make your life easier.
+
+## Installing a pre-push hook
+
+CI will automatically fail your build if it doesn't pass `tidy`, our
+internal tool for ensuring code quality. If you'd like, you can install a
+[Git hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks)
+that will automatically run `./x.py test tidy --bless` on each push, to ensure
+your code is up to par. If you decide later that this behavior is
+undesirable, you can delete the `pre-push` file in `.git/hooks`.
+
+A prebuilt git hook lives at [`src/etc/pre-push.sh`](https://github.com/rust-lang/rust/blob/master/src/etc/pre-push.sh) which can be copied into your `.git/hooks` folder as `pre-push` (without the `.sh` extension!).
+
+You can also install the hook as a step of running `./x.py setup`!
+
+## Configuring `rust-analyzer` for `rustc`
+
+`rust-analyzer` can help you check and format your code whenever you save
+a file. By default, `rust-analyzer` runs the `cargo check` and `rustfmt`
+commands, but you can override these commands to use more adapted versions
+of these tools when hacking on `rustc`. For example, for Visual Studio Code,
+you can write: <!-- date: 2022-04 --><!-- the date comment is for the edition below -->
+
+```JSON
+{
+    "rust-analyzer.checkOnSave.overrideCommand": [
+        "python3",
+        "x.py",
+        "check",
+        "--json-output"
+    ],
+    "rust-analyzer.rustfmt.overrideCommand": [
+        "./build/$TARGET_TRIPLE/stage0/bin/rustfmt",
+        "--edition=2021"
+    ],
+    "rust-analyzer.procMacro.enable": true,
+    "rust-analyzer.cargo.buildScripts.enable": true,
+    "rust-analyzer.cargo.buildScripts.overrideCommand": [
+        "python3",
+        "x.py",
+        "check",
+        "--json-output"
+    ],
+    "rust-analyzer.rustc.source": "./Cargo.toml",
+}
+```
+
+in your `.vscode/settings.json` file. This will ask `rust-analyzer` to use
+`./x.py check` to check the sources, and the stage 0 rustfmt to format them.
+
+> NOTE: Make sure to replace `TARGET_TRIPLE` in the `rust-analyzer.rustfmt.overrideCommand`
+> setting with the appropriate target triple for your machine. An example of such
+> a triple is `x86_64-unknown-linux-gnu`. An easy way to check your target triple
+> is to run `rustc -vV` and checking the `host` value of its output.
+
+If you have enough free disk space and you would like to be able to run `x.py` commands while
+rust-analyzer runs in the background, you can also add `--build-dir build-rust-analyzer` to the
+`overrideCommand` to avoid x.py locking.
+
+If you're running `coc.nvim`, you can use `:CocLocalConfig` to create a
+`.vim/coc-settings.json` and enter the same settings as above, but replacing
+`editor.formatOnSave: true,` with
+`"coc.preferences.formatOnSaveFiletypes": ["rust"],`.
+
+If running `./x.py check` on save is inconvenient, in VS Code you can use a [Build
+Task] instead:
+
+```JSON
+// .vscode/tasks.json
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "./x.py check",
+            "command": "./x.py check",
+            "type": "shell",
+            "problemMatcher": "$rustc",
+            "presentation": { "clear": true },
+            "group": { "kind": "build", "isDefault": true }
+        }
+    ]
+}
+```
+
+[Build Task]: https://code.visualstudio.com/docs/editor/tasks
+
+## Check, check, and check again
+
+When doing simple refactorings, it can be useful to run `./x.py check`
+continuously. If you set up `rust-analyzer` as described above, this will
+be done for you every time you save a file. Here you are just checking that
+the compiler can **build**, but often that is all you need (e.g., when renaming a
+method). You can then run `./x.py build` when you actually need to
+run tests.
+
+In fact, it is sometimes useful to put off tests even when you are not
+100% sure the code will work. You can then keep building up
+refactoring commits and only run the tests at some later time. You can
+then use `git bisect` to track down **precisely** which commit caused
+the problem. A nice side-effect of this style is that you are left
+with a fairly fine-grained set of commits at the end, all of which
+build and pass tests. This often helps reviewing.
+
+## Configuring `rustup` to use nightly
+
+Some parts of the bootstrap process uses pinned, nightly versions of tools like
+rustfmt. To make things like `cargo fmt` work correctly in your repo, run
+
+```console
+cd <path to rustc repo>
+rustup override set nightly
+```
+
+after [installing a nightly toolchain] with `rustup`. Don't forget to do this for all
+directories you have [setup a worktree for]. You may need to use the pinned
+nightly version from `src/stage0.json`, but often the normal `nightly` channel
+will work.
+
+**Note** see [the section on vscode] for how to configure it with this real rustfmt `x.py` uses,
+and [the section on rustup] for how to setup `rustup` toolchain for your bootstrapped compiler
+
+**Note** This does _not_ allow you to build `rustc` with cargo directly. You
+still have to use `x.py` to work on the compiler or standard library, this just
+lets you use `cargo fmt`.
+
+[installing a nightly toolchain]: https://rust-lang.github.io/rustup/concepts/channels.html?highlight=nightl#working-with-nightly-rust
+[setup a worktree for]: ./suggested.md#working-on-multiple-branches-at-the-same-time
+[the section on vscode]: suggested.md#configuring-rust-analyzer-for-rustc
+[the section on rustup]: how-to-build-and-run.md?highlight=rustup#creating-a-rustup-toolchain
+
+## Incremental builds with `--keep-stage`.
+
+Sometimes just checking
+whether the compiler builds is not enough. A common example is that
+you need to add a `debug!` statement to inspect the value of some
+state or better understand the problem. In that case, you really need
+a full build. By leveraging incremental, though, you can often get
+these builds to complete very fast (e.g., around 30 seconds). The only
+catch is this requires a bit of fudging and may produce compilers that
+don't work (but that is easily detected and fixed).
+
+The sequence of commands you want is as follows:
+
+- Initial build: `./x.py build library`
+  - As [documented previously], this will build a functional
+    stage1 compiler as part of running all stage0 commands (which include
+    building a `std` compatible with the stage1 compiler) as well as the
+    first few steps of the "stage 1 actions" up to "stage1 (sysroot stage1)
+    builds std".
+- Subsequent builds: `./x.py build library --keep-stage 1`
+  - Note that we added the `--keep-stage 1` flag here
+
+[documented previously]: ./how-to-build-and-run.md#building-the-compiler
+
+As mentioned, the effect of `--keep-stage 1` is that we just _assume_ that the
+old standard library can be re-used. If you are editing the compiler, this
+is almost always true: you haven't changed the standard library, after
+all. But sometimes, it's not true: for example, if you are editing
+the "metadata" part of the compiler, which controls how the compiler
+encodes types and other states into the `rlib` files, or if you are
+editing things that wind up in the metadata (such as the definition of
+the MIR).
+
+**The TL;DR is that you might get weird behavior from a compile when
+using `--keep-stage 1`** -- for example, strange
+[ICEs](../appendix/glossary.html#ice) or other panics. In that case, you
+should simply remove the `--keep-stage 1` from the command and
+rebuild. That ought to fix the problem.
+
+You can also use `--keep-stage 1` when running tests. Something like this:
+
+- Initial test run: `./x.py test src/test/ui`
+- Subsequent test run: `./x.py test src/test/ui --keep-stage 1`
+
+## Fine-tuning optimizations
+
+Setting `optimize = false` makes the compiler too slow for tests. However, to
+improve the test cycle, you can disable optimizations selectively only for the
+crates you'll have to rebuild
+([source](https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/incremental.20compilation.20question/near/202712165)).
+For example, when working on `rustc_mir_build`, the `rustc_mir_build` and
+`rustc_driver` crates take the most time to incrementally rebuild. You could
+therefore set the following in the root `Cargo.toml`:
+
+```toml
+[profile.release.package.rustc_mir_build]
+opt-level = 0
+[profile.release.package.rustc_driver]
+opt-level = 0
+```
+
+## Working on multiple branches at the same time
+
+Working on multiple branches in parallel can be a little annoying, since
+building the compiler on one branch will cause the old build and the
+incremental compilation cache to be overwritten. One solution would be
+to have multiple clones of the repository, but that would mean storing the
+Git metadata multiple times, and having to update each clone individually.
+
+Fortunately, Git has a better solution called [worktrees]. This lets you
+create multiple "working trees", which all share the same Git database.
+Moreover, because all of the worktrees share the same object database,
+if you update a branch (e.g. master) in any of them, you can use the new
+commits from any of the worktrees. One caveat, though, is that submodules
+do not get shared. They will still be cloned multiple times.
+
+[worktrees]: https://git-scm.com/docs/git-worktree
+
+Given you are inside the root directory for your Rust repository, you can
+create a "linked working tree" in a new "rust2" directory by running
+the following command:
+
+```bash
+git worktree add ../rust2
+```
+
+Creating a new worktree for a new branch based on `master` looks like:
+
+```bash
+git worktree add -b my-feature ../rust2 master
+```
+
+You can then use that rust2 folder as a separate workspace for modifying
+and building `rustc`!
+
+## Using nix-shell
+
+If you're using nix, you can use the following nix-shell to work on Rust:
+
+```nix
+{ pkgs ? import <nixpkgs> {} }:
+
+# This file contains a development shell for working on rustc.
+let
+  # Build configuration for rust-lang/rust. Based on `config.toml.example` from
+  # `1bd30ce2aac40c7698aa4a1b9520aa649ff2d1c5`.
+  config = pkgs.writeText "rustc-config" ''
+    profile = "compiler" # you may want to choose a different profile, like `library` or `tools`
+    changelog-seen = 2
+
+    [build]
+    # The path to (or name of) the GDB executable to use. This is only used for
+    # executing the debuginfo test suite.
+    gdb = "${pkgs.gdb}/bin/gdb"
+    python = "${pkgs.python3Full}/bin/python"
+
+    [rust]
+    debug = true
+    incremental = true
+    deny-warnings = false
+
+    # Indicates whether some LLVM tools, like llvm-objdump, will be made available in the
+    # sysroot.
+    llvm-tools = true
+
+    # Print backtrace on internal compiler errors during bootstrap
+    backtrace-on-ice = true
+  '';
+
+  ripgrepConfig =
+    let
+      # Files that are ignored by ripgrep when searching.
+      ignoreFile = pkgs.writeText "rustc-rgignore" ''
+        configure
+        config.toml.example
+        x.py
+        LICENSE-MIT
+        LICENSE-APACHE
+        COPYRIGHT
+        **/*.txt
+        **/*.toml
+        **/*.yml
+        **/*.nix
+        *.md
+        src/ci
+        src/etc/
+        src/llvm-emscripten/
+        src/llvm-project/
+        src/rtstartup/
+        src/rustllvm/
+        src/stdsimd/
+        src/tools/rls/rls-analysis/test_data/
+      '';
+    in
+    pkgs.writeText "rustc-ripgreprc" "--ignore-file=${ignoreFile}";
+in
+pkgs.mkShell {
+  name = "rustc";
+  nativeBuildInputs = with pkgs; [
+    gcc9 binutils cmake ninja openssl pkgconfig python39 git curl cacert patchelf nix psutils
+  ];
+  RIPGREP_CONFIG_PATH = ripgrepConfig;
+  RUST_BOOTSTRAP_CONFIG = config;
+}
+```
diff --git a/src/doc/rustc-dev-guide/src/cli.md b/src/doc/rustc-dev-guide/src/cli.md
new file mode 100644
index 000000000..408ae2070
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/cli.md
@@ -0,0 +1,33 @@
+# Command-line Arguments
+
+Command-line flags are documented in the [rustc book][cli-docs]. All *stable*
+flags should be documented there. Unstable flags should be documented in the
+[unstable book].
+
+See the [forge guide for new options] for details on the *procedure* for
+adding a new command-line argument.
+
+## Guidelines
+
+- Flags should be orthogonal to each other. For example, if we'd have a
+  json-emitting variant of multiple actions `foo` and `bar`, an additional
+  `--json` flag is better than adding `--foo-json` and `--bar-json`.
+- Avoid flags with the `no-` prefix. Instead, use the [`parse_bool`] function,
+  such as `-C embed-bitcode=no`.
+- Consider the behavior if the flag is passed multiple times. In some
+  situations, the values should be accumulated (in order!). In other
+  situations, subsequent flags should override previous flags (for example,
+  the lint-level flags). And some flags (like `-o`) should generate an error
+  if it is too ambiguous what multiple flags would mean.
+- Always give options a long descriptive name, if only for more understandable
+  compiler scripts.
+- The `--verbose` flag is for adding verbose information to `rustc`
+  output. For example, using it with the `--version`
+  flag gives information about the hashes of the compiler code.
+- Experimental flags and options must be guarded behind the `-Z
+  unstable-options` flag.
+
+[cli-docs]: https://doc.rust-lang.org/rustc/command-line-arguments.html
+[forge guide for new options]: https://forge.rust-lang.org/compiler/new_option.html
+[unstable book]: https://doc.rust-lang.org/nightly/unstable-book/
+[`parse_bool`]: https://github.com/rust-lang/rust/blob/e5335592e78354e33d798d20c04bcd677c1df62d/src/librustc_session/options.rs#L307-L313
diff --git a/src/doc/rustc-dev-guide/src/closure.md b/src/doc/rustc-dev-guide/src/closure.md
new file mode 100644
index 000000000..b43be3213
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/closure.md
@@ -0,0 +1,215 @@
+# Closure Expansion in rustc
+
+This section describes how rustc handles closures. Closures in Rust are
+effectively "desugared" into structs that contain the values they use (or
+references to the values they use) from their creator's stack frame. rustc has
+the job of figuring out which values a closure uses and how, so it can decide
+whether to capture a given variable by shared reference, mutable reference, or
+by move. rustc also has to figure out which of the closure traits ([`Fn`][fn],
+[`FnMut`][fn_mut], or [`FnOnce`][fn_once]) a closure is capable of
+implementing.
+
+[fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html
+[fn_mut]:https://doc.rust-lang.org/std/ops/trait.FnMut.html
+[fn_once]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html
+
+Let's start with a few examples:
+
+### Example 1
+
+To start, let's take a look at how the closure in the following example is desugared:
+
+```rust
+fn closure(f: impl Fn()) {
+    f();
+}
+
+fn main() {
+    let x: i32 = 10;
+    closure(|| println!("Hi {}", x));  // The closure just reads x.
+    println!("Value of x after return {}", x);
+}
+```
+
+Let's say the above is the content of a file called `immut.rs`. If we compile
+`immut.rs` using the following command. The [`-Z dump-mir=all`][dump-mir] flag will cause
+`rustc` to generate and dump the [MIR][mir] to a directory called `mir_dump`.
+```console
+> rustc +stage1 immut.rs -Z dump-mir=all
+```
+
+[mir]: ./mir/index.md
+[dump-mir]: ./mir/passes.md
+
+After we run this command, we will see a newly generated directory in our
+current working directory called `mir_dump`, which will contain several files.
+If we look at file `rustc.main.-------.mir_map.0.mir`, we will find, among
+other things, it also contains this line:
+
+```rust,ignore
+_4 = &_1;
+_3 = [closure@immut.rs:7:13: 7:36] { x: move _4 };
+```
+
+Note that in the MIR examples in this chapter, `_1` is `x`.
+
+Here in first line `_4 = &_1;`, the `mir_dump` tells us that `x` was borrowed
+as an immutable reference.  This is what we would hope as our closure just
+reads `x`.
+
+### Example 2
+
+Here is another example:
+
+```rust
+fn closure(mut f: impl FnMut()) {
+    f();
+}
+
+fn main() {
+    let mut x: i32 = 10;
+    closure(|| {
+        x += 10;  // The closure mutates the value of x
+        println!("Hi {}", x)
+    });
+    println!("Value of x after return {}", x);
+}
+```
+
+```rust,ignore
+_4 = &mut _1;
+_3 = [closure@mut.rs:7:13: 10:6] { x: move _4 };
+```
+This time along, in the line `_4 = &mut _1;`, we see that the borrow is changed to mutable borrow.
+Fair enough! The closure increments `x` by 10.
+
+### Example 3
+
+One more example:
+
+```rust
+fn closure(f: impl FnOnce()) {
+    f();
+}
+
+fn main() {
+    let x = vec![21];
+    closure(|| {
+        drop(x);  // Makes x unusable after the fact.
+    });
+    // println!("Value of x after return {:?}", x);
+}
+```
+
+```rust,ignore
+_6 = [closure@move.rs:7:13: 9:6] { x: move _1 }; // bb16[3]: scope 1 at move.rs:7:13: 9:6
+```
+Here, `x` is directly moved into the closure and the access to it will not be permitted after the
+closure.
+
+## Inferences in the compiler
+
+Now let's dive into rustc code and see how all these inferences are done by the compiler.
+
+Let's start with defining a term that we will be using quite a bit in the rest of the discussion -
+*upvar*. An **upvar** is a variable that is local to the function where the closure is defined. So,
+in the above examples, **x** will be an upvar to the closure. They are also sometimes referred to as
+the *free variables* meaning they are not bound to the context of the closure.
+[`compiler/rustc_middle/src/ty/query/mod.rs`][upvars] defines a query called *upvars_mentioned*
+for this purpose.
+
+[upvars]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_query_impl/queries/struct.upvars_mentioned.html
+
+Other than lazy invocation, one other thing that distinguishes a closure from a
+normal function is that it can use the upvars. It borrows these upvars from its surrounding
+context; therefore the compiler has to determine the upvar's borrow type. The compiler starts with
+assigning an immutable borrow type and lowers the restriction (that is, changes it from
+**immutable** to **mutable** to **move**) as needed, based on the usage. In the Example 1 above, the
+closure only uses the variable for printing but does not modify it in any way and therefore, in the
+`mir_dump`, we find the borrow type for the upvar `x` to be immutable.  In example 2, however, the
+closure modifies `x` and increments it by some value.  Because of this mutation, the compiler, which
+started off assigning `x` as an immutable reference type, has to adjust it as a mutable reference.
+Likewise in the third example, the closure drops the vector and therefore this requires the variable
+`x` to be moved into the closure. Depending on the borrow kind, the closure has to implement the
+appropriate trait: `Fn` trait for immutable borrow, `FnMut` for mutable borrow,
+and `FnOnce` for move semantics.
+
+Most of the code related to the closure is in the
+[`compiler/rustc_typeck/src/check/upvar.rs`][upvar] file and the data structures are
+declared in the file [`compiler/rustc_middle/src/ty/mod.rs`][ty].
+
+[upvar]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/check/upvar/index.html
+[ty]:https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/index.html
+
+Before we go any further, let's discuss how we can examine the flow of control through the rustc
+codebase. For closures specifically, set the `RUST_LOG` env variable as below and collect the
+output in a file:
+
+```console
+> RUST_LOG=rustc_typeck::check::upvar rustc +stage1 -Z dump-mir=all \
+    <.rs file to compile> 2> <file where the output will be dumped>
+```
+
+This uses the stage1 compiler and enables `debug!` logging for the
+`rustc_typeck::check::upvar` module.
+
+The other option is to step through the code using lldb or gdb.
+
+1. `rust-lldb build/x86_64-apple-darwin/stage1/bin/rustc test.rs`
+2. In lldb:
+    1. `b upvar.rs:134`  // Setting the breakpoint on a certain line in the upvar.rs file`
+    2. `r`  // Run the program until it hits the breakpoint
+
+Let's start with [`upvar.rs`][upvar]. This file has something called
+the [`euv::ExprUseVisitor`] which walks the source of the closure and
+invokes a callback for each upvar that is borrowed, mutated, or moved.
+
+[`euv::ExprUseVisitor`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/expr_use_visitor/struct.ExprUseVisitor.html
+
+```rust
+fn main() {
+    let mut x = vec![21];
+    let _cl = || {
+        let y = x[0];  // 1.
+        x[0] += 1;  // 2.
+    };
+}
+```
+
+In the above example, our visitor will be called twice, for the lines marked 1 and 2, once for a
+shared borrow and another one for a mutable borrow. It will also tell us what was borrowed.
+
+The callbacks are defined by implementing the [`Delegate`] trait. The
+[`InferBorrowKind`][ibk] type implements `Delegate` and keeps a map that
+records for each upvar which mode of capture was required. The modes of capture
+can be `ByValue` (moved) or `ByRef` (borrowed). For `ByRef` borrows, the possible
+[`BorrowKind`]s are `ImmBorrow`, `UniqueImmBorrow`, `MutBorrow` as defined in the
+[`compiler/rustc_middle/src/ty/mod.rs`][middle_ty].
+
+[`BorrowKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.BorrowKind.html
+[middle_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/index.html
+
+`Delegate` defines a few different methods (the different callbacks):
+**consume** for *move* of a variable, **borrow** for a *borrow* of some kind
+(shared or mutable), and **mutate** when we see an *assignment* of something.
+
+All of these callbacks have a common argument *cmt* which stands for Category,
+Mutability and Type and is defined in
+[`compiler/rustc_middle/src/middle/mem_categorization.rs`][cmt]. Borrowing from the code
+comments, "`cmt` is a complete categorization of a value indicating where it
+originated and how it is located, as well as the mutability of the memory in
+which the value is stored". Based on the callback (consume, borrow etc.), we
+will call the relevant `adjust_upvar_borrow_kind_for_<something>` and pass the
+`cmt` along. Once the borrow type is adjusted, we store it in the table, which
+basically says what borrows were made for each closure.
+
+```rust,ignore
+self.tables
+    .borrow_mut()
+    .upvar_capture_map
+    .extend(delegate.adjust_upvar_captures);
+```
+
+[`Delegate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/expr_use_visitor/trait.Delegate.html
+[ibk]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/check/upvar/struct.InferBorrowKind.html
+[cmt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/mem_categorization/index.html
diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md
new file mode 100644
index 000000000..8f46e896e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md
@@ -0,0 +1,282 @@
+# Debugging the compiler
+[debugging]: #debugging
+
+<!-- toc -->
+
+This chapter contains a few tips to debug the compiler. These tips aim to be
+useful no matter what you are working on.  Some of the other chapters have
+advice about specific parts of the compiler (e.g. the [Queries Debugging and
+Testing chapter](./incrcomp-debugging.html) or the [LLVM Debugging
+chapter](./backend/debugging.md)).
+
+## Configuring the compiler
+
+By default, rustc is built without most debug information. To enable debug info,
+set `debug = true` in your config.toml.
+
+Setting `debug = true` turns on many different debug options (e.g., `debug-assertions`,
+`debug-logging`, etc.) which can be individually tweaked if you want to, but many people
+simply set `debug = true`. Check out the comments in config.toml.example for more info.
+
+You will need to rebuild the compiler once you've changed any configuration options.
+
+## `-Z` flags
+
+The compiler has a bunch of `-Z` flags. These are unstable flags that are only
+enabled on nightly. Many of them are useful for debugging. To get a full listing
+of `-Z` flags, use `-Z help`.
+
+One useful flag is `-Z verbose`, which generally enables printing more info that
+could be useful for debugging.
+
+## Getting a backtrace
+[getting-a-backtrace]: #getting-a-backtrace
+
+When you have an ICE (panic in the compiler), you can set
+`RUST_BACKTRACE=1` to get the stack trace of the `panic!` like in
+normal Rust programs. IIRC backtraces **don't work** on MinGW,
+sorry. If you have trouble or the backtraces are full of `unknown`,
+you might want to find some way to use Linux, Mac, or MSVC on Windows.
+
+In the default configuration (without `debug` set to `true`), you don't have line numbers
+enabled, so the backtrace looks like this:
+
+```text
+stack backtrace:
+   0: std::sys::imp::backtrace::tracing::imp::unwind_backtrace
+   1: std::sys_common::backtrace::_print
+   2: std::panicking::default_hook::{{closure}}
+   3: std::panicking::default_hook
+   4: std::panicking::rust_panic_with_hook
+   5: std::panicking::begin_panic
+   (~~~~ LINES REMOVED BY ME FOR BREVITY ~~~~)
+  32: rustc_typeck::check_crate
+  33: <std::thread::local::LocalKey<T>>::with
+  34: <std::thread::local::LocalKey<T>>::with
+  35: rustc::ty::context::TyCtxt::create_and_enter
+  36: rustc_driver::driver::compile_input
+  37: rustc_driver::run_compiler
+```
+
+If you set `debug = true`, you will get line numbers for the stack trace.
+Then the backtrace will look like this:
+
+```text
+stack backtrace:
+   (~~~~ LINES REMOVED BY ME FOR BREVITY ~~~~)
+             at /home/user/rust/compiler/rustc_typeck/src/check/cast.rs:110
+   7: rustc_typeck::check::cast::CastCheck::check
+             at /home/user/rust/compiler/rustc_typeck/src/check/cast.rs:572
+             at /home/user/rust/compiler/rustc_typeck/src/check/cast.rs:460
+             at /home/user/rust/compiler/rustc_typeck/src/check/cast.rs:370
+   (~~~~ LINES REMOVED BY ME FOR BREVITY ~~~~)
+  33: rustc_driver::driver::compile_input
+             at /home/user/rust/compiler/rustc_driver/src/driver.rs:1010
+             at /home/user/rust/compiler/rustc_driver/src/driver.rs:212
+  34: rustc_driver::run_compiler
+             at /home/user/rust/compiler/rustc_driver/src/lib.rs:253
+```
+
+## Getting a backtrace for errors
+[getting-a-backtrace-for-errors]: #getting-a-backtrace-for-errors
+
+If you want to get a backtrace to the point where the compiler emits an
+error message, you can pass the `-Z treat-err-as-bug=n`, which will make
+the compiler panic on the `nth` error on `delay_span_bug`. If you leave
+off `=n`, the compiler will assume `1` for `n` and thus panic on the
+first error it encounters.
+
+This can also help when debugging `delay_span_bug` calls - it will make
+the first `delay_span_bug` call panic, which will give you a useful backtrace.
+
+For example:
+
+```bash
+$ cat error.rs
+```
+
+```rust
+fn main() {
+    1 + ();
+}
+```
+
+```bash
+$ rustc +stage1 error.rs
+error[E0277]: cannot add `()` to `{integer}`
+ --> error.rs:2:7
+  |
+2 |       1 + ();
+  |         ^ no implementation for `{integer} + ()`
+  |
+  = help: the trait `Add<()>` is not implemented for `{integer}`
+
+error: aborting due to previous error
+```
+
+Now, where does the error above come from?
+
+```bash
+$ RUST_BACKTRACE=1 rustc +stage1 error.rs -Z treat-err-as-bug
+error[E0277]: the trait bound `{integer}: std::ops::Add<()>` is not satisfied
+ --> error.rs:2:7
+  |
+2 |     1 + ();
+  |       ^ no implementation for `{integer} + ()`
+  |
+  = help: the trait `std::ops::Add<()>` is not implemented for `{integer}`
+
+error: internal compiler error: unexpected panic
+
+note: the compiler unexpectedly panicked. this is a bug.
+
+note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports
+
+note: rustc 1.24.0-dev running on x86_64-unknown-linux-gnu
+
+note: run with `RUST_BACKTRACE=1` for a backtrace
+
+thread 'rustc' panicked at 'encountered error with `-Z treat_err_as_bug',
+/home/user/rust/compiler/rustc_errors/src/lib.rs:411:12
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose
+backtrace.
+stack backtrace:
+  (~~~ IRRELEVANT PART OF BACKTRACE REMOVED BY ME ~~~)
+   7: rustc::traits::error_reporting::<impl rustc::infer::InferCtxt<'a, 'tcx>>
+             ::report_selection_error
+             at /home/user/rust/compiler/rustc_middle/src/traits/error_reporting.rs:823
+   8: rustc::traits::error_reporting::<impl rustc::infer::InferCtxt<'a, 'tcx>>
+             ::report_fulfillment_errors
+             at /home/user/rust/compiler/rustc_middle/src/traits/error_reporting.rs:160
+             at /home/user/rust/compiler/rustc_middle/src/traits/error_reporting.rs:112
+   9: rustc_typeck::check::FnCtxt::select_obligations_where_possible
+             at /home/user/rust/compiler/rustc_typeck/src/check/mod.rs:2192
+  (~~~ IRRELEVANT PART OF BACKTRACE REMOVED BY ME ~~~)
+  36: rustc_driver::run_compiler
+             at /home/user/rust/compiler/rustc_driver/src/lib.rs:253
+```
+
+Cool, now I have a backtrace for the error!
+
+## Getting logging output
+
+The compiler uses the [`tracing`] crate for logging.
+
+[`tracing`]: https://docs.rs/tracing
+
+For details see [the guide section on tracing](./tracing.md)
+
+## Formatting Graphviz output (.dot files)
+[formatting-graphviz-output]: #formatting-graphviz-output
+
+Some compiler options for debugging specific features yield graphviz graphs -
+e.g. the `#[rustc_mir(borrowck_graphviz_postflow="suffix.dot")]` attribute
+dumps various borrow-checker dataflow graphs.
+
+These all produce `.dot` files. To view these files, install graphviz (e.g.
+`apt-get install graphviz`) and then run the following commands:
+
+```bash
+$ dot -T pdf maybe_init_suffix.dot > maybe_init_suffix.pdf
+$ firefox maybe_init_suffix.pdf # Or your favorite pdf viewer
+```
+
+## Viewing Spanview output (.html files)
+[viewing-spanview-output]: #viewing-spanview-output
+
+In addition to [graphviz output](#formatting-graphviz-output-dot-files), MIR debugging
+flags include an option to generate a MIR representation called `Spanview` that
+uses HTML to highlight code regions in the original source code and display
+compiler metadata associated with each region.
+[`-Z dump-mir-spanview`](./mir/debugging.md), for example, highlights spans
+associated with each MIR `Statement`, `Terminator`, and/or `BasicBlock`.
+
+These `.html` files use CSS features to dynamically expand spans obscured by
+overlapping spans, and native tooltips (based on the HTML `title` attribute) to
+reveal the actual MIR elements, as text.
+
+To view these files, simply use a modern browser, or a CSS-capable HTML preview
+feature in a modern IDE. (The default HTML preview pane in *VS Code* is known to
+work, for instance.)
+
+## Narrowing (Bisecting) Regressions
+
+The [cargo-bisect-rustc][bisect] tool can be used as a quick and easy way to
+find exactly which PR caused a change in `rustc` behavior. It automatically
+downloads `rustc` PR artifacts and tests them against a project you provide
+until it finds the regression. You can then look at the PR to get more context
+on *why* it was changed.  See [this tutorial][bisect-tutorial] on how to use
+it.
+
+[bisect]: https://github.com/rust-lang/cargo-bisect-rustc
+[bisect-tutorial]: https://github.com/rust-lang/cargo-bisect-rustc/blob/master/TUTORIAL.md
+
+## Downloading Artifacts from Rust's CI
+
+The [rustup-toolchain-install-master][rtim] tool by kennytm can be used to
+download the artifacts produced by Rust's CI for a specific SHA1 -- this
+basically corresponds to the successful landing of some PR -- and then sets
+them up for your local use. This also works for artifacts produced by `@bors
+try`. This is helpful when you want to examine the resulting build of a PR
+without doing the build yourself.
+
+[rtim]: https://github.com/kennytm/rustup-toolchain-install-master
+
+## Debugging type layouts
+
+The (permanently) unstable `#[rustc_layout]` attribute can be used to dump
+the [`Layout`] of the type it is attached to. For example:
+
+```rust
+#![feature(rustc_attrs)]
+
+#[rustc_layout(debug)]
+type T<'a> = &'a u32;
+```
+
+Will emit the following:
+
+```text
+error: layout_of(&'a u32) = Layout {
+    fields: Primitive,
+    variants: Single {
+        index: 0,
+    },
+    abi: Scalar(
+        Scalar {
+            value: Pointer,
+            valid_range: 1..=18446744073709551615,
+        },
+    ),
+    largest_niche: Some(
+        Niche {
+            offset: Size {
+                raw: 0,
+            },
+            scalar: Scalar {
+                value: Pointer,
+                valid_range: 1..=18446744073709551615,
+            },
+        },
+    ),
+    align: AbiAndPrefAlign {
+        abi: Align {
+            pow2: 3,
+        },
+        pref: Align {
+            pow2: 3,
+        },
+    },
+    size: Size {
+        raw: 8,
+    },
+}
+ --> src/lib.rs:4:1
+  |
+4 | type T<'a> = &'a u32;
+  | ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+```
+
+[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/abi/struct.Layout.html
diff --git a/src/doc/rustc-dev-guide/src/compiler-src.md b/src/doc/rustc-dev-guide/src/compiler-src.md
new file mode 100644
index 000000000..ad6968bb4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/compiler-src.md
@@ -0,0 +1,203 @@
+# High-level overview of the compiler source
+
+<!-- toc -->
+
+Now that we have [seen what the compiler does](./overview.md), let's take a
+look at the structure of the [`rust-lang/rust`] repository, where the rustc
+source code lives.
+
+[`rust-lang/rust`]: https://github.com/rust-lang/rust
+
+> You may find it helpful to read the ["Overview of the compiler"](./overview.md)
+> chapter, which introduces how the compiler works, before this one.
+
+## Workspace structure
+
+The `rust-lang/rust` repository consists of a single large cargo workspace
+containing the compiler, the standard libraries (`core`, `alloc`, `std`,
+`proc_macro`, etc), and `rustdoc`, along with the build system and a bunch of
+tools and submodules for building a full Rust distribution.
+
+The repository consists of three main directories:
+
+- `compiler/` contains the source code for `rustc`. It consists of many crates
+  that together make up the compiler.
+  
+- `library/` contains the standard libraries (`core`, `alloc`, `std`,
+  `proc_macro`, `test`), as well as the Rust runtime (`backtrace`, `rtstartup`,
+  `lang_start`).
+  
+- `src/` contains the source code for rustdoc, clippy, cargo, the build system,
+  compiler tests, language docs, etc.
+
+## Compiler
+
+The compiler is implemented in the various `compiler/` crates.
+The `compiler/` crates all have names starting with `rustc_*`. These are a
+collection of around 50 interdependent crates ranging in size from tiny to
+huge. There is also the `rustc` crate which is the actual binary (i.e. the
+`main` function); it doesn't actually do anything besides calling the
+`rustc_driver` crate, which drives the various parts of compilation in other
+crates.
+
+The dependency structure of these crates is complex, but roughly it is
+something like this:
+
+- `rustc` (the binary) calls [`rustc_driver::main`][main].
+    - [`rustc_driver`] depends on a lot of other crates, but the main one is
+      [`rustc_interface`].
+        - [`rustc_interface`] depends on most of the other compiler crates. It
+          is a fairly generic interface for driving the whole compilation.
+            - Most of the other `rustc_*` crates depend on [`rustc_middle`],
+              which defines a lot of central data structures in the compiler.
+                - [`rustc_middle`] and most of the other crates depend on a
+                  handful of crates representing the early parts of the
+                  compiler (e.g. the parser), fundamental data structures (e.g.
+                  [`Span`]), or error reporting: [`rustc_data_structures`],
+                  [`rustc_span`], [`rustc_errors`], etc.
+
+[main]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/fn.main.html
+[`rustc_driver`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/index.html
+[`rustc_interface`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/index.html
+[`rustc_middle`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/index.html
+[`rustc_data_structures`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/index.html
+[`rustc_span`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/index.html
+[`Span`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html
+[`rustc_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/index.html
+
+You can see the exact dependencies by reading the `Cargo.toml` for the various
+crates, just like a normal Rust crate.
+
+One final thing: [`src/llvm-project`] is a submodule for our fork of LLVM.
+During bootstrapping, LLVM is built and the [`compiler/rustc_llvm`] crate
+contains Rust wrappers around LLVM (which is written in C++), so that the
+compiler can interface with it.
+
+Most of this book is about the compiler, so we won't have any further
+explanation of these crates here.
+
+[`src/llvm-project`]: https://github.com/rust-lang/rust/tree/master/src/
+[`compiler/rustc_llvm`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_llvm
+
+### Big picture
+
+The dependency structure is influenced by two main factors:
+
+1. Organization. The compiler is a _huge_ codebase; it would be an impossibly
+   large crate. In part, the dependency structure reflects the code structure
+   of the compiler.
+2. Compile time. By breaking the compiler into multiple crates, we can take
+   better advantage of incremental/parallel compilation using cargo. In
+   particular, we try to have as few dependencies between crates as possible so
+   that we don't have to rebuild as many crates if you change one.
+
+At the very bottom of the dependency tree are a handful of crates that are used
+by the whole compiler (e.g. [`rustc_span`]). The very early parts of the
+compilation process (e.g. parsing and the AST) depend on only these.
+
+After the AST is constructed and other early analysis is done, the compiler's [query system][query]
+gets set up. The query system is set up in a clever way using function
+pointers. This allows us to break dependencies between crates, allowing more
+parallel compilation.
+The query system is defined in [`rustc_middle`], so nearly all
+subsequent parts of the compiler depend on this crate. It is a really large
+crate, leading to long compile times. Some efforts have been made to move stuff
+out of it with limited success. Another unfortunate side effect is that sometimes
+related functionality gets scattered across different crates. For example,
+linting functionality is scattered across earlier parts of the crate,
+[`rustc_lint`], [`rustc_middle`], and other places.
+
+[`rustc_lint`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/index.html
+
+Ideally there would be fewer, more
+cohesive crates, with incremental and parallel compilation making sure compile
+times stay reasonable. However, our incremental and parallel compilation haven't
+gotten good enough for that yet, so breaking things into separate crates has
+been our solution so far.
+
+At the top of the dependency tree are the [`rustc_interface`] and
+[`rustc_driver`] crates. [`rustc_interface`] is an unstable wrapper around the
+query system that helps to drive the various stages of compilation. Other
+consumers of the compiler may use this interface in different ways (e.g.
+rustdoc or maybe eventually rust-analyzer). The [`rustc_driver`] crate first
+parses command line arguments and then uses [`rustc_interface`] to drive the
+compilation to completion.
+
+[query]: ./query.md
+
+[orgch]: ./overview.md
+
+## rustdoc
+
+The bulk of `rustdoc` is in [`librustdoc`]. However, the `rustdoc` binary
+itself is [`src/tools/rustdoc`], which does nothing except call [`rustdoc::main`].
+
+There is also javascript and CSS for the rustdocs in [`src/tools/rustdoc-js`]
+and [`src/tools/rustdoc-themes`].
+
+You can read more about rustdoc in [this chapter][rustdocch].
+
+[`librustdoc`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/index.html
+[`rustdoc::main`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/fn.main.html
+[`src/tools/rustdoc`]:  https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
+[`src/tools/rustdoc-js`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-js
+[`src/tools/rustdoc-themes`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-themes
+
+[rustdocch]: ./rustdoc.md
+
+## Tests
+
+The test suite for all of the above is in [`src/test/`]. You can read more
+about the test suite [in this chapter][testsch].
+
+The test harness itself is in [`src/tools/compiletest`].
+
+[testsch]: ./tests/intro.md
+
+[`src/test/`]: https://github.com/rust-lang/rust/tree/master/src/test
+[`src/tools/compiletest`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest
+
+## Build System
+
+There are a number of tools in the repository just for building the compiler,
+standard library, rustdoc, etc, along with testing, building a full Rust
+distribution, etc.
+
+One of the primary tools is [`src/bootstrap`]. You can read more about
+bootstrapping [in this chapter][bootstch]. The process may also use other tools
+from `src/tools/`, such as [`tidy`] or [`compiletest`].
+
+[`src/bootstrap`]: https://github.com/rust-lang/rust/tree/master/src/bootstrap
+[`tidy`]: https://github.com/rust-lang/rust/tree/master/src/tools/tidy
+[`compiletest`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest
+
+[bootstch]: ./building/bootstrapping.md
+
+## Standard library
+
+The standard library crates are all in `library/`. They have intuitive names
+like `std`, `core`, `alloc`, etc.  There is also `proc_macro`, `test`, and
+other runtime libraries.
+
+This code is fairly similar to most other Rust crates except that it must be
+built in a special way because it can use unstable features.
+
+## Other
+
+There are a lot of other things in the `rust-lang/rust` repo that are related
+to building a full Rust distribution. Most of the time you don't need to worry
+about them.
+
+These include:
+- [`src/ci`]: The CI configuration. This actually quite extensive because we
+  run a lot of tests on a lot of platforms.
+- [`src/doc`]: Various documentation, including submodules for a few books.
+- [`src/etc`]: Miscellaneous utilities.
+- [`src/tools/rustc-workspace-hack`], and others: Various workarounds to make
+  cargo work with bootstrapping.
+- And more...
+
+[`src/ci`]: https://github.com/rust-lang/rust/tree/master/src/ci
+[`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
+[`src/etc`]: https://github.com/rust-lang/rust/tree/master/src/etc
+[`src/tools/rustc-workspace-hack`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustc-workspace-hack
diff --git a/src/doc/rustc-dev-guide/src/compiler-team.md b/src/doc/rustc-dev-guide/src/compiler-team.md
new file mode 100644
index 000000000..abdeac3d2
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/compiler-team.md
@@ -0,0 +1,139 @@
+# About the compiler team
+
+rustc is maintained by the [Rust compiler team][team]. The people who belong to
+this team collectively work to track regressions and implement new features.
+Members of the Rust compiler team are people who have made significant
+contributions to rustc and its design.
+
+[team]: https://www.rust-lang.org/governance/teams/compiler
+
+## Discussion
+
+Currently the compiler team chats in Zulip:
+
+- Team chat occurs in the [`t-compiler`][zulip-t-compiler] stream on the Zulip instance
+- There are also a number of other associated Zulip streams,
+  such as [`t-compiler/help`][zulip-help], where people can ask for help
+  with rustc development, or [`t-compiler/meetings`][zulip-meetings],
+  where the team holds their weekly triage and steering meetings.
+
+## Expert map
+
+If you're interested in figuring out who can answer questions about a
+particular part of the compiler, or you'd just like to know who works on what,
+check out our [experts directory][experts].
+It contains a listing of the various parts of the compiler and a list of people
+who are experts on each one.
+
+[experts]: https://github.com/rust-lang/compiler-team/blob/master/content/experts/map.toml
+
+## Rust compiler meeting
+
+The compiler team has a weekly meeting where we do triage and try to
+generally stay on top of new bugs, regressions, and discuss important
+things in general.
+They are held on [Zulip][zulip-meetings]. It works roughly as follows:
+
+- **Announcements, MCPs/FCPs, and WG-check-ins:** We share some
+  announcements with the rest of the team about important things we want
+  everyone to be aware of. We also share the status of MCPs and FCPs and we
+  use the opportunity to have a couple of WGs giving us an update about
+  their work.
+- **Check for beta and stable nominations:** These are nominations of things to
+  backport to beta and stable respectively.
+  We then look for new cases where the compiler broke previously working
+  code in the wild. Regressions are important issues to fix, so it's
+  likely that they are tagged as P-critical or P-high; the major
+  exception would be bug fixes (though even there we often [aim to give
+  warnings first][procedure]).
+- **Review P-critical and P-high bugs:** P-critical and P-high bugs are
+  those that are sufficiently important for us to actively track
+  progress. P-critical and P-high bugs should ideally always have an
+  assignee.
+- **Check S-waiting-on-team and I-nominated issues:** These are issues where feedback from
+  the team is desired.
+- **Look over the performance triage report:** We check for PRs that made the
+    performance worse and try to decide if it's worth reverting the performance regression or if
+    the regression can be addressed in a future PR.
+
+The meeting currently takes place on Thursdays at 10am Boston time
+(UTC-4 typically, but daylight savings time sometimes makes things
+complicated).
+
+[procedure]: ./bug-fix-procedure.md
+[zulip-t-compiler]: https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler
+[zulip-help]: https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp
+[zulip-meetings]: https://rust-lang.zulipchat.com/#narrow/stream/238009-t-compiler.2Fmeetings
+
+## Team membership
+
+Membership in the Rust team is typically offered when someone has been
+making significant contributions to the compiler for some
+time. Membership is both a recognition but also an obligation:
+compiler team members are generally expected to help with upkeep as
+well as doing reviews and other work.
+
+If you are interested in becoming a compiler team member, the first
+thing to do is to start fixing some bugs, or get involved in a working
+group. One good way to find bugs is to look for
+[open issues tagged with E-easy](https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy)
+or
+[E-mentor](https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-mentor).
+
+You can also dig through the graveyard of PRs that were
+[closed due to inactivity](https://github.com/rust-lang/rust/pulls?q=is%3Apr+label%3AS-inactive),
+some of them may contain work that is still useful - refer to the
+associated issues, if any - and only needs some finishing touches
+for which the original author didn't have time.
+
+### r+ rights
+
+Once you have made a number of individual PRs to rustc, we will often
+offer r+ privileges. This means that you have the right to instruct
+"bors" (the robot that manages which PRs get landed into rustc) to
+merge a PR
+([here are some instructions for how to talk to bors][homu-guide]).
+
+[homu-guide]: https://bors.rust-lang.org/
+
+The guidelines for reviewers are as follows:
+
+- You are always welcome to review any PR, regardless of who it is
+  assigned to.  However, do not r+ PRs unless:
+  - You are confident in that part of the code.
+  - You are confident that nobody else wants to review it first.
+    - For example, sometimes people will express a desire to review a
+      PR before it lands, perhaps because it touches a particularly
+      sensitive part of the code.
+- Always be polite when reviewing: you are a representative of the
+  Rust project, so it is expected that you will go above and beyond
+  when it comes to the [Code of Conduct].
+
+[Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct
+
+### high-five
+
+Once you have r+ rights, you can also be added to the [high-five][hi5]
+rotation. high-five is the bot that assigns incoming PRs to
+reviewers. If you are added, you will be randomly selected to review
+PRs. If you find you are assigned a PR that you don't feel comfortable
+reviewing, you can also leave a comment like `r? @so-and-so` to assign
+to someone else — if you don't know who to request, just write `r?
+@nikomatsakis for reassignment` and @nikomatsakis will pick someone
+for you.
+
+[hi5]: https://github.com/rust-highfive
+
+Getting on the high-five list is much appreciated as it lowers the
+review burden for all of us! However, if you don't have time to give
+people timely feedback on their PRs, it may be better that you don't
+get on the list.
+
+### Full team membership
+
+Full team membership is typically extended once someone made many
+contributions to the Rust compiler over time, ideally (but not
+necessarily) to multiple areas. Sometimes this might be implementing a
+new feature, but it is also important — perhaps more important! — to
+have time and willingness to help out with general upkeep such as
+bugfixes, tracking regressions, and other less glamorous work.
diff --git a/src/doc/rustc-dev-guide/src/const-eval.md b/src/doc/rustc-dev-guide/src/const-eval.md
new file mode 100644
index 000000000..5a11f8cdd
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/const-eval.md
@@ -0,0 +1,45 @@
+# Constant Evaluation
+
+Constant evaluation is the process of computing values at compile time. For a
+specific item (constant/static/array length) this happens after the MIR for the
+item is borrow-checked and optimized. In many cases trying to const evaluate an
+item will trigger the computation of its MIR for the first time.
+
+Prominent examples are:
+
+* The initializer of a `static`
+* Array length
+    * needs to be known to reserve stack or heap space
+* Enum variant discriminants
+    * needs to be known to prevent two variants from having the same
+      discriminant
+* Patterns
+    * need to be known to check for overlapping patterns
+
+Additionally constant evaluation can be used to reduce the workload or binary
+size at runtime by precomputing complex operations at compiletime and only
+storing the result.
+
+Constant evaluation can be done by calling the `const_eval_*` functions of `TyCtxt`.
+They're the wrappers of the `const_eval` query.
+
+The `const_eval_*` functions use a [`ParamEnv`](./param_env.html) of environment
+in which the constant is evaluated (e.g. the function within which the constant is used)
+and a [`GlobalId`]. The `GlobalId` is made up of an `Instance` referring to a constant
+or static or of an `Instance` of a function and an index into the function's `Promoted` table.
+
+Constant evaluation returns a [`EvalToConstValueResult`] with either the error, or a
+representation of the constant. `static` initializers are always represented as
+[`miri`](./miri.html) virtual memory allocations (via [`ConstValue::ByRef`]).
+Other constants get represented as [`ConstValue::Scalar`]
+or [`ConstValue::Slice`] if possible. This means that the `const_eval_*`
+functions cannot be used to create miri-pointers to the evaluated constant.
+If you need the value of a constant inside Miri, you need to directly work with
+[`const_to_op`].
+
+[`GlobalId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/struct.GlobalId.html
+[`ConstValue::Scalar`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/value/enum.ConstValue.html#variant.Scalar
+[`ConstValue::Slice`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/value/enum.ConstValue.html#variant.Slice
+[`ConstValue::ByRef`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/value/enum.ConstValue.html#variant.ByRef
+[`EvalToConstValueResult`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/error/type.EvalToConstValueResult.html
+[`const_to_op`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.InterpCx.html#method.const_to_op
diff --git a/src/doc/rustc-dev-guide/src/constants.md b/src/doc/rustc-dev-guide/src/constants.md
new file mode 100644
index 000000000..4f1027b98
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/constants.md
@@ -0,0 +1,82 @@
+# Constants in the type system
+
+Constants used in the type system are represented as [`ty::Const`].
+The variants of their [`ty::ConstKind`] mostly mirror the variants of [`ty::TyKind`]
+with the two *additional* variants being `ConstKind::Value` and `ConstKind::Unevaluated`.
+
+## `WithOptConstParam` and dealing with the query system
+
+To typecheck constants used in the type system, we have to know their expected type.
+For const arguments in type dependent paths, e.g. `x.foo::<{ 3 + 4 }>()`, we don't know
+the expected type for `{ 3 + 4 }` until we are typechecking the containing function.
+
+As we may however have to evaluate that constant during this typecheck, we would get a cycle error.
+For more details, you can look at [this document](https://hackmd.io/@rust-const-generics/Bk5GHW-Iq).
+
+## Unevaluated constants
+
+*This section talks about what's happening with `feature(generic_const_exprs)` enabled.
+On stable we do not yet supply any generic parameters to anonymous constants,
+avoiding most of the issues mentioned here.*
+
+Unless a constant is either a simple literal, e.g. `[u8; 3]` or `foo::<{ 'c' }>()`,
+or a generic parameter, e.g. `[u8; N]`, converting a constant to its [`ty::Const`] representation
+returns an unevaluated constant. Even fully concrete constants which do not depend on
+generic parameters are not evaluated right away.
+
+Anonymous constants are typechecked separately from their containing item, e.g.
+```rust
+fn foo<const N: usize>() -> [u8; N + 1] {
+    [0; N + 1]
+}
+```
+is treated as
+```rust
+const ANON_CONST_1<const N: usize> = N + 1;
+const ANON_CONST_2<const N: usize> = N + 1;
+fn foo<const N: usize>() -> [u8; ANON_CONST_1::<N>] {
+    [0; ANON_CONST_2::<N>]
+}
+```
+
+### Unifying constants
+
+For the compiler, `ANON_CONST_1` and `ANON_CONST_2` are completely different, so
+we have to somehow look into unevaluated constants to check whether they should
+unify.
+
+For this we use [InferCtxt::try_unify_abstract_consts](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.try_unify_abstract_consts).
+This builds a custom AST for the two inputs from their THIR. This is then used for
+the actual comparison.
+
+### Lazy normalization for constants
+
+We do not eagerly evaluate constant as they can be used in the `where`-clauses of their
+parent item, for example:
+
+```rust
+#[feature(generic_const_exprs)]
+fn foo<T: Trait>()
+where
+    [u8; <T as  Trait>::ASSOC + 1]: SomeOtherTrait,
+{}
+```
+
+The constant `<T as  Trait>::ASSOC + 1` depends on the `T: Trait` bound of
+its parents caller bounds, but is also part of another bound itself.
+If we were to eagerly evaluate this constant while computing its parents bounds
+this would cause a query cycle.
+
+### Unused generic arguments of anonymous constants
+
+Anonymous constants inherit the generic parameters of their parent, which is
+why the array length in `foo<const N: usize>() -> [u8; N + 1]` can use `N`.
+
+Without any manual adjustments, this causes us to include parameters even if
+the constant doesn't use them in any way. This can cause
+[some interesting errors][pcg-unused-substs] and breaks some already stable code.
+
+[`ty::Const`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Const.html
+[`ty::ConstKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.ConstKind.html
+[`ty::TyKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html
+[pcg-unused-substs]: https://github.com/rust-lang/project-const-generics/blob/master/design-docs/anon-const-substs.md#unused-substs
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
new file mode 100644
index 000000000..45f8c9033
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -0,0 +1,595 @@
+# Contributing to Rust
+
+Thank you for your interest in contributing to Rust! There are many ways to
+contribute, and we appreciate all of them.
+
+<!-- toc -->
+
+If you have questions, please make a post on [internals.rust-lang.org][internals] or
+hop on the [Rust Discord server][rust-discord] or [Rust Zulip server][rust-zulip].
+
+As a reminder, all contributors are expected to follow our [Code of Conduct][coc].
+
+If this is your first time contributing, the [Getting Started] and
+[walkthrough] chapters can give you a good example of how a typical
+contribution would go.
+
+[internals]: https://internals.rust-lang.org
+[rust-discord]: http://discord.gg/rust-lang
+[rust-zulip]: https://rust-lang.zulipchat.com
+[coc]: https://www.rust-lang.org/conduct.html
+[walkthrough]: ./walkthrough.md
+[Getting Started]: ./getting-started.md
+
+## Feature Requests
+
+Feature requests need to go through a process to be approved by the relevant
+teams. Usually this requires a Final Comment Period (FCP) or even a Request for
+Comments (RFC). See [Getting Started] for more information about these processes.
+
+## Bug Reports
+
+While bugs are unfortunate, they're a reality in software. We can't fix what we
+don't know about, so please report liberally. If you're not sure if something
+is a bug or not, feel free to file a bug anyway.
+
+**If you believe reporting your bug publicly represents a security risk to Rust users,
+please follow our [instructions for reporting security vulnerabilities][vuln]**.
+
+[vuln]: https://www.rust-lang.org/policies/security
+
+If you're using the nightly channel, please check if the bug exists in the
+latest toolchain before filing your bug. It might be fixed already.
+
+If you have the chance, before reporting a bug, please [search existing
+issues](https://github.com/rust-lang/rust/issues?q=is%3Aissue),
+as it's possible that someone else has already reported your error. This doesn't
+always work, and sometimes it's hard to know what to search for, so consider this
+extra credit. We won't mind if you accidentally file a duplicate report.
+
+Similarly, to help others who encountered the bug find your issue, consider
+filing an issue with a descriptive title, which contains information that might
+be unique to it.  This can be the language or compiler feature used, the
+conditions that trigger the bug, or part of the error message if there is any.
+An example could be: **"impossible case reached" on lifetime inference for impl
+Trait in return position**.
+
+Opening an issue is as easy as following [this
+link](https://github.com/rust-lang/rust/issues/new/choose) and filling out the fields
+in the appropriate provided template.
+
+## Pull Requests
+
+Pull requests (or PRs for short) are the primary mechanism we use to change Rust.
+GitHub itself has some [great documentation][about-pull-requests] on using the
+Pull Request feature. We use the "fork and pull" model [described here][development-models],
+where contributors push changes to their personal fork and create pull requests to
+bring those changes into the source repository. We have more info about how to use git
+when contributing to Rust under [the git section](./git.md).
+
+[about-pull-requests]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests
+[development-models]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/getting-started/about-collaborative-development-models#fork-and-pull-model
+
+### r?
+
+All pull requests are reviewed by another person. We have a bot,
+[@rust-highfive][rust-highfive], that will automatically assign a random person
+to review your request based on which files you changed.
+
+If you want to request that a specific person reviews your pull request, you
+can add an `r?` to the pull request description or in a comment. For example,
+if you want to ask a review to @awesome-reviewer, add
+
+    r? @awesome-reviewer
+
+to the end of the pull request description, and [@rust-highfive][rust-highfive] will assign
+them instead of a random person. This is entirely optional.
+
+You can also assign a random reviewer from a specific team by writing `r? rust-lang/groupname`.
+So if you were making a diagnostics change, then you could get a reviewer from the diagnostics
+team by adding:
+
+    r? rust-lang/diagnostics
+
+For a full list of possible `groupname` check the `groups` section at the
+[rust highfive config file](https://github.com/rust-lang/highfive/blob/master/highfive/configs/rust-lang/rust.json).
+
+### CI
+
+In addition to being reviewed by a human, pull requests are automatically tested
+thanks to continuous integration (CI). Basically, every time you open and update
+a pull request, CI builds the compiler and tests it against the
+[compiler test suite][rctd], and also performs other tests such as checking that
+your pull request is in compliance with Rust's style guidelines.
+
+Running continuous integration tests allows PR authors to catch mistakes early
+without going through a first review cycle, and also helps reviewers stay aware
+of the status of a particular pull request.
+
+Rust has plenty of CI capacity, and you should never have to worry about wasting
+computational resources each time you push a change. It is also perfectly fine
+(and even encouraged!) to use the CI to test your changes if it can help your
+productivity. In particular, we don't recommend running the full `./x.py test` suite locally,
+since it takes a very long time to execute.
+
+### r+
+
+After someone has reviewed your pull request, they will leave an annotation
+on the pull request with an `r+`. It will look something like this:
+
+    @bors r+
+
+This tells [@bors], our lovable integration bot, that your pull request has
+been approved. The PR then enters the [merge queue][merge-queue], where [@bors]
+will run *all* the tests on *every* platform we support. If it all works out,
+[@bors] will merge your code into `master` and close the pull request.
+
+Depending on the scale of the change, you may see a slightly different form of `r+`:
+
+    @bors r+ rollup
+
+The additional `rollup` tells [@bors] that this change should always be "rolled up".
+Changes that are rolled up are tested and merged alongside other PRs, to
+speed the process up. Typically only small changes that are expected not to conflict
+with one another are marked as "always roll up".
+
+[rust-highfive]: https://github.com/rust-highfive
+[@bors]: https://github.com/bors
+[merge-queue]: https://bors.rust-lang.org/queue/rust
+
+### Opening a PR
+
+You are now ready to file a pull request? Great! Here are a few points you
+should be aware of.
+
+All pull requests should be filed against the `master` branch, except in very
+particular scenarios. Unless you know for sure that you should target another
+branch, `master` will be the right choice (it's also the default).
+
+Make sure your pull request is in compliance with Rust's style guidelines by running
+
+    $ ./x.py test tidy --bless
+
+We recommend to make this check before every pull request (and every new commit
+in a pull request); you can add [git hooks](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks)
+before every push to make sure you never forget to make this check. The
+CI will also run tidy and will fail if tidy fails.
+
+Rust follows a _no merge-commit policy_, meaning, when you encounter merge
+conflicts you are expected to always rebase instead of merging.  E.g. always use
+rebase when bringing the latest changes from the master branch to your feature
+branch.
+
+If you encounter merge conflicts or when a reviewer asks you to perform some
+changes, your PR will get marked as `S-waiting-on-author`. When you resolve
+them, you should use `@rustbot` to mark it as `S-waiting-on-review`:
+
+    @rustbot label -S-waiting-on-author +S-waiting-on-review
+
+See [this chapter][labeling] for more details.
+
+GitHub allows [closing issues using keywords][closing-keywords]. This feature
+should be used to keep the issue tracker tidy. However, it is generally preferred
+to put the "closes #123" text in the PR description rather than the issue commit;
+particularly during rebasing, citing the issue number in the commit can "spam"
+the issue in question.
+
+[labeling]: ./rustbot.md#issue-relabeling
+[closing-keywords]: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+
+### External Dependencies (subtree)
+
+As a developer to this repository, you don't have to treat the following external projects
+differently from other crates that are directly in this repo:
+
+* [Clippy](https://github.com/rust-lang/rust-clippy)
+* [rustfmt](https://github.com/rust-lang/rustfmt)
+* [rust-analyzer](https://github.com/rust-lang/rust-analyzer)
+
+In contrast to `submodule` dependencies
+(see below for those), the `subtree` dependencies are just regular files and directories which can
+be updated in tree. However, enhancements, bug fixes, etc. specific to these tools should be filed
+against the tools directly in their respective upstream repositories.
+
+#### Synchronizing a subtree
+
+Periodically the changes made to subtree based dependencies need to be synchronized between this
+repository and the upstream tool repositories.
+
+Subtree synchronizations are typically handled by the respective tool maintainers. Other users
+are welcome to submit synchronization PRs, however, in order to do so you you will need to modify
+your local git installation and follow a very precise set of instructions.
+These instructions are documented, along with several useful tips and tricks, in the
+[syncing subtree changes][clippy-sync-docs] section in Clippy's Contributing guide.
+The instructions are applicable for use with any subtree based tool, just be sure to
+use the correct corresponding subtree directory and remote repository.
+
+The synchronization process goes in two directions: `subtree push` and `subtree pull`.
+
+A `subtree push` takes all the changes that happened to the copy in this repo and creates commits
+on the remote repo that match the local changes. Every local
+commit that touched the subtree causes a commit on the remote repo, but
+is modified to move the files from the specified directory to the tool repo root.
+
+A `subtree pull` takes all changes since the last `subtree pull`
+from the tool repo and adds these commits to the rustc repo along with a merge commit that moves
+the tool changes into the specified directory in the Rust repository.
+
+It is recommended that you always do a push first and get that merged to the tool master branch.
+Then, when you do a pull, the merge works without conflicts.
+While it's definitely possible to resolve conflicts during a pull, you may have to redo the conflict
+resolution if your PR doesn't get merged fast enough and there are new conflicts. Do not try to
+rebase the result of a `git subtree pull`, rebasing merge commits is a bad idea in general.
+
+You always need to specify the `-P` prefix to the subtree directory and the corresponding remote
+repository. If you specify the wrong directory or repository
+you'll get very fun merges that try to push the wrong directory to the wrong remote repository.
+Luckily you can just abort this without any consequences by throwing away either the pulled commits
+in rustc or the pushed branch on the remote and try again. It is usually fairly obvious
+that this is happening because you suddenly get thousands of commits that want to be synchronized.
+
+[clippy-sync-docs]: https://doc.rust-lang.org/nightly/clippy/development/infrastructure/sync.html
+
+#### Creating a new subtree dependency
+
+If you want to create a new subtree dependency from an existing repository, call (from this
+repository's root directory!)
+
+```
+git subtree add -P src/tools/clippy https://github.com/rust-lang/rust-clippy.git master
+```
+
+This will create a new commit, which you may not rebase under any circumstances! Delete the commit
+and redo the operation if you need to rebase.
+
+Now you're done, the `src/tools/clippy` directory behaves as if Clippy were
+part of the rustc monorepo, so no one but you (or others that synchronize
+subtrees) actually needs to use `git subtree`.
+
+
+### External Dependencies (submodules)
+
+Currently building Rust will also build the following external projects:
+
+* [miri](https://github.com/rust-lang/miri)
+* [rls](https://github.com/rust-lang/rls/)
+
+We allow breakage of these tools in the nightly channel. Maintainers of these
+projects will be notified of the breakages and should fix them as soon as
+possible.
+
+After the external is fixed, one could add the changes with
+
+```sh
+git add path/to/submodule
+```
+
+outside the submodule.
+
+In order to prepare your tool-fixing PR, you can run the build locally by doing
+`./x.py build src/tools/TOOL`. If you will be editing the sources
+there, you may wish to set `submodules = false` in the `config.toml`
+to prevent `x.py` from resetting to the original branch.
+
+Breakage is not allowed in the beta and stable channels, and must be addressed
+before the PR is merged.
+
+#### Breaking Tools Built With The Compiler
+
+Rust's build system builds a number of tools that make use of the internals of
+the compiler and that are hosted in a separate repository, and included in Rust
+via git submodules. This includes [RLS](https://github.com/rust-lang/rls) and
+[Miri](https://github.com/rust-lang/Miri). If these tools break because of your
+changes, you may run into a sort of "chicken and egg" problem. These tools rely
+on the latest compiler to be built so you can't update them (in their own
+repositories) to reflect your changes to the compiler until those changes are
+merged into the compiler. At the same time, you can't get your changes merged
+into the compiler because the rust-lang/rust build won't pass until those tools
+build and pass their tests.
+
+Luckily, a feature was
+[added to Rust's build](https://github.com/rust-lang/rust/issues/45861) to make
+all of this easy to handle. The idea is that we allow these tools to be
+"broken", so that the rust-lang/rust build passes without trying to build them,
+then land the change in the compiler, and go update the tools that you
+broke. Some tools will require waiting for a nightly release before this can
+happen, while others use the builds uploaded after each bors merge and thus can
+be updated immediately (check the tool's documentation for details). Once you're
+done and the tools are working again, you go back in the compiler and update the
+tools so they can be distributed again.
+
+This should avoid a bunch of synchronization dances and is also much easier on contributors as
+there's no need to block on rls/miri/other tools changes going upstream.
+
+Here are those same steps in detail:
+
+1. (optional) First, if it doesn't exist already, create a `config.toml` by copying
+   `config.toml.example` in the root directory of the Rust repository.
+   Set `submodules = false` in the `[build]` section. This will prevent `x.py`
+   from resetting to the original branch after you make your changes. If you
+   need to [update any submodules to their latest versions](#updating-submodules),
+   see the section of this file about that for more information.
+2. (optional) Run `./x.py test src/tools/rls` (substituting the submodule
+   that broke for `rls`). Fix any errors in the submodule (and possibly others).
+3. (optional) Make commits for your changes and send them to upstream repositories as a PR.
+4. (optional) Maintainers of these submodules will **not** merge the PR. The PR can't be
+   merged because CI will be broken. You'll want to write a message on the PR referencing
+   your change, and how the PR should be merged once your change makes it into a nightly.
+5. Wait for your PR to merge.
+6. Wait for a nightly
+7. (optional) Help land your PR on the upstream repository now that your changes are in nightly.
+8. (optional) Send a PR to rust-lang/rust updating the submodule.
+
+#### Updating submodules
+
+These instructions are specific to updating `rls`, however they may apply
+to the other submodules as well. Please help by improving these instructions
+if you find any discrepancies or special cases that need to be addressed.
+
+To update the `rls` submodule, start by running the appropriate
+[`git submodule` command](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
+For example, to update to the latest commit on the remote master branch,
+you may want to run:
+```
+git submodule update --remote src/tools/rls
+```
+If you run `./x.py build` now, and you are lucky, it may just work. If you see
+an error message about patches that did not resolve to any crates, you will need
+to complete a few more steps which are outlined with their rationale below.
+
+*(This error may change in the future to include more information.)*
+```
+error: failed to resolve patches for `https://github.com/rust-lang/rls`
+
+Caused by:
+  patch for `rls` in `https://github.com/rust-lang/rls` did not resolve to any crates
+failed to run: ~/rust/build/x86_64-unknown-linux-gnu/stage0/bin/cargo build --manifest-path ~/rust/src/bootstrap/Cargo.toml
+```
+
+The [`[patch]`][patchsec] section of `Cargo.toml` can be very useful for
+testing. In addition to that, you should read the [Overriding
+dependencies][overriding] section of the documentation.
+
+[patchsec]: http://doc.crates.io/manifest.html#the-patch-section
+[overriding]: http://doc.crates.io/specifying-dependencies.html#overriding-dependencies
+
+Specifically, the following [section in Overriding dependencies][testingbugfix]
+reveals what the problem is:
+
+[testingbugfix]: http://doc.crates.io/specifying-dependencies.html#testing-a-bugfix
+
+> Next up we need to ensure that our lock file is updated to use this new
+> version of uuid so our project uses the locally checked out copy instead of
+> one from crates.io. The way `[patch]` works is that it'll load the dependency
+> at ../path/to/uuid and then whenever crates.io is queried for versions of
+> uuid it'll also return the local version.
+>
+> This means that the version number of the local checkout is significant and
+> will affect whether the patch is used. Our manifest declared uuid = "1.0"
+> which means we'll only resolve to >= 1.0.0, < 2.0.0, and Cargo's greedy
+> resolution algorithm also means that we'll resolve to the maximum version
+> within that range. Typically this doesn't matter as the version of the git
+> repository will already be greater or match the maximum version published on
+> crates.io, but it's important to keep this in mind!
+
+This says that when we updated the submodule, the version number in our
+`src/tools/rls/Cargo.toml` changed. The new version is different from
+the version in `Cargo.lock`, so the build can no longer continue.
+
+To resolve this, we need to update `Cargo.lock`. Luckily, cargo provides a
+command to do this easily.
+
+```
+$ cargo update -p rls
+```
+
+This should change the version listed in `Cargo.lock` to the new version you updated
+the submodule to. Running `./x.py build` should work now.
+
+## Writing Documentation
+
+Documentation improvements are very welcome. The source of `doc.rust-lang.org`
+is located in [`src/doc`] in the tree, and standard API documentation is generated
+from the source code itself (e.g. [`lib.rs`]). Documentation pull requests function
+in the same way as other pull requests.
+
+[`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
+[`lib.rs`]: https://github.com/rust-lang/rust/blob/master/library/std/src/lib.rs#L1
+
+To find documentation-related issues, sort by the [A-docs label][adocs].
+
+[adocs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen%20is%3Aissue%20label%3AA-docs
+
+You can find documentation style guidelines in [RFC 1574][rfc1574].
+
+[rfc1574]: https://github.com/rust-lang/rfcs/blob/master/text/1574-more-api-documentation-conventions.md#appendix-a-full-conventions-text
+
+In many cases, you don't need a full `./x.py doc --stage 2`, which will build
+the entire stage 2 compiler and compile the various books published on
+[doc.rust-lang.org][docs]. When updating documentation for the standard library,
+first try `./x.py doc library`. If that fails, or if you need to
+see the output from the latest version of `rustdoc`, add `--stage 1`.
+Results should appear in `build/$TARGET/doc`.
+
+[docs]: https://doc.rust-lang.org
+
+You can also use `rustdoc` directly to check small fixes. For example,
+`rustdoc src/doc/reference.md` will render reference to `doc/reference.html`.
+The CSS might be messed up, but you can verify that the HTML is right.
+
+### Contributing to rustc-dev-guide
+
+Contributions to the [rustc-dev-guide][rdg] are always welcome, and can be made directly at
+[the rust-lang/rustc-dev-guide repo][rdgrepo].
+The issue tracker in that repo is also a great way to find things that need doing.
+There are issues for beginners and advanced compiler devs alike!
+
+Just a few things to keep in mind:
+
+- Please limit line length to 100 characters. This is enforced by CI, and you can run the checks
+  locally with `ci/check_line_lengths.sh`.
+
+- When contributing text to the guide, please contextualize the information with some time period
+  and/or a reason so that the reader knows how much to trust or mistrust the information.
+  Aim to provide a reasonable amount of context, possibly including but not limited to:
+
+  - A reason for why the data may be out of date other than "change", as change is a constant across
+    the project.
+
+  - The date the comment was added, e.g. instead of writing _"Currently, ..."_
+    or _"As of now, ..."_, consider writing
+    _"As of January 2021, ..."_.
+    Try to format the date as `<MONTH> <YEAR>` to ease search.
+
+  - Additionally, include a machine-readable comment of the form `<!-- date:
+    2022-04 -->` (if the current month is April 2022). We have an automated
+    tool that uses these (in `ci/date-check`).
+
+    So, for the month of April 2022, the comment would look like: `As of <!--
+    date: 2022-04 --> April 2022`. Make sure to put the comment *between* `as of`
+    and `April 2022`; see [PR #1066][rdg#1066] for the rationale.
+
+  - A link to a relevant WG, tracking issue, `rustc` rustdoc page, or similar, that may provide
+    further explanation for the change process or a way to verify that the information is not
+    outdated.
+
+- If a text grows rather long (more than a few page scrolls) or complicated (more than four
+  subsections) it might benefit from having a Table of Contents at the beginning, which you can
+  auto-generate by including the `<!-- toc -->` marker.
+
+[rdg]: https://rustc-dev-guide.rust-lang.org/
+[rdgrepo]: https://github.com/rust-lang/rustc-dev-guide
+[rdg#1066]: https://github.com/rust-lang/rustc-dev-guide/pull/1066
+
+## Issue Triage
+
+Sometimes, an issue will stay open, even though the bug has been fixed. And
+sometimes, the original bug may go stale because something has changed in the
+meantime.
+
+It can be helpful to go through older bug reports and make sure that they are
+still valid. Load up an older issue, double check that it's still true, and
+leave a comment letting us know if it is or is not. The [least recently
+updated sort][lru] is good for finding issues like this.
+
+[Thanks to `@rustbot`][rustbot], anyone can help triage issues by adding
+appropriate labels to issues that haven't been triaged yet:
+
+* Yellow, **A**-prefixed labels state which **area** of the project an issue
+  relates to.
+
+* Magenta, **B**-prefixed labels identify bugs which are **blockers**.
+
+* Dark blue, **beta-** labels track changes which need to be backported into
+  the beta branches.
+
+* Light purple, **C**-prefixed labels represent the **category** of an issue.
+
+* Green, **E**-prefixed labels explain the level of **experience** necessary
+  to fix the issue.
+
+* The dark blue **final-comment-period** label marks bugs that are using the
+  RFC signoff functionality of [rfcbot] and are currently in the final
+  comment period.
+
+* Red, **I**-prefixed labels indicate the **importance** of the issue. The
+  [I-nominated][inom] label indicates that an issue has been nominated for
+  discussion at the next meeting of the team tagged using a
+  **T**-prefixed label. Similarly, the [I-prioritize][ipri] indicates
+  that an issue has been requested to be prioritized by the appropriate
+  team.
+
+* The purple **metabug** label marks lists of bugs collected by other
+  categories.
+
+* Purple gray, **O**-prefixed labels are the **operating system** or platform
+  that this issue is specific to.
+
+* Orange, **P**-prefixed labels indicate a bug's **priority**. These labels
+  can be assigned by anyone that understand the issue and is able to
+  prioritize it, and replace the [I-prioritize][ipri] label.
+
+* The gray **proposed-final-comment-period** label marks bugs that are using
+  the RFC signoff functionality of [rfcbot] and are currently awaiting
+  signoff of all team members in order to enter the final comment period.
+
+* Pink, **regression**-prefixed labels track regressions from stable to the
+  release channels.
+
+* The light orange **relnotes** label marks issues that should be documented in
+  the release notes of the next release.
+
+* Gray, **S**-prefixed labels are used for tracking the **status** of pull
+  requests.
+
+* Blue, **T**-prefixed bugs denote which **team** the issue belongs to.
+
+If you're looking for somewhere to start, check out the [E-easy][eeasy] tag.
+
+[rustbot]: ./rustbot.md
+[inom]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-nominated
+[ipri]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-prioritize
+[eeasy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
+[lru]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc
+[rfcbot]: https://github.com/anp/rfcbot-rs/
+
+## Out-of-tree Contributions
+
+There are a number of other ways to contribute to Rust that don't deal with
+rust-lang/rust:
+
+* Answer questions in the _Get Help!_ channels on the [Rust Discord
+  server][rust-discord], on [users.rust-lang.org][users], or on
+  [StackOverflow][so].
+* Participate in the [RFC process](https://github.com/rust-lang/rfcs).
+* Find a [requested community library][community-library], build it, and publish
+  it to [Crates.io](http://crates.io). Easier said than done, but very, very
+  valuable!
+
+[rust-discord]: https://discord.gg/rust-lang
+[users]: https://users.rust-lang.org/
+[so]: http://stackoverflow.com/questions/tagged/rust
+[community-library]: https://github.com/rust-lang/rfcs/labels/A-community-library
+
+## Helpful Links and Information
+
+For people new to Rust, and just starting to contribute, or even for
+more seasoned developers, some useful places to look for information
+are:
+
+* This guide contains information about how various parts of the
+  compiler work and how to contribute to the compiler
+* [Rust Forge][rustforge] contains additional documentation, including
+  write-ups of how to achieve common tasks
+* The [Rust Internals forum][rif], a place to ask questions and
+  discuss Rust's internals
+* The [generated documentation for Rust's compiler][gdfrustc]
+* The [Rust reference][rr], even though it doesn't specifically talk about
+  Rust's internals, is a great resource nonetheless
+* Although out of date, [Tom Lee's great blog article][tlgba] is very helpful
+* [rustaceans.org][ro] is helpful, but mostly dedicated to IRC
+* The [Rust Compiler Testing Docs][rctd]
+* For [@bors], [this cheat sheet][cheatsheet] is helpful
+* Google is always helpful when programming.
+  You can [search all Rust documentation][gsearchdocs] (the standard library,
+  the compiler, the books, the references, and the guides) to quickly find
+  information about the language and compiler.
+* You can also use Rustdoc's built-in search feature to find documentation on
+  types and functions within the crates you're looking at. You can also search
+  by type signature! For example, searching for `* -> vec` should find all
+  functions that return a `Vec<T>`.
+  _Hint:_ Find more tips and keyboard shortcuts by typing `?` on any Rustdoc
+  page!
+* Don't be afraid to ask! The Rust community is friendly and helpful.
+
+[rustc dev guide]: about-this-guide.md
+[gdfrustc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/
+[gsearchdocs]: https://www.google.com/search?q=site:doc.rust-lang.org+your+query+here
+[stddocs]: https://doc.rust-lang.org/std
+[rif]: http://internals.rust-lang.org
+[rr]: https://doc.rust-lang.org/book/README.html
+[rustforge]: https://forge.rust-lang.org/
+[tlgba]: https://tomlee.co/2014/04/a-more-detailed-tour-of-the-rust-compiler/
+[ro]: https://www.rustaceans.org/
+[rctd]: tests/intro.md
+[cheatsheet]: https://bors.rust-lang.org/
diff --git a/src/doc/rustc-dev-guide/src/conventions.md b/src/doc/rustc-dev-guide/src/conventions.md
new file mode 100644
index 000000000..15d125377
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/conventions.md
@@ -0,0 +1,152 @@
+This file offers some tips on the coding conventions for rustc.  This
+chapter covers [formatting](#formatting), [coding for correctness](#cc),
+[using crates from crates.io](#cio), and some tips on
+[structuring your PR for easy review](#er).
+
+<a name="formatting"></a>
+
+# Formatting and the tidy script
+
+rustc is moving towards the [Rust standard coding style][fmt].
+
+However, for now we don't use stable `rustfmt`; we use a pinned version with a
+special config, so this may result in different style from normal [`rustfmt`].
+Therefore, formatting this repository using `cargo fmt` is not recommended.
+
+Instead, formatting should be done using `./x.py fmt`. It's a good habit to run
+`./x.py fmt` before every commit, as this reduces conflicts later. 
+
+Formatting is checked by the `tidy` script. It runs automatically when you do
+`./x.py test` and can be run in isolation with `./x.py fmt --check`.
+
+If you want to use format-on-save in your editor, the pinned version of
+`rustfmt` is built under `build/<target>/stage0/bin/rustfmt`. You'll have to
+pass the <!-- date: 2022-04 --> `--edition=2021` argument yourself when calling
+`rustfmt` directly.
+
+[fmt]: https://github.com/rust-dev-tools/fmt-rfcs
+[`rustfmt`]:https://github.com/rust-lang/rustfmt
+
+<a name="copyright"></a>
+
+### Copyright notice
+
+In the past, files began with a copyright and license notice. Please **omit**
+this notice for new files licensed under the standard terms (dual
+MIT/Apache-2.0).
+
+All of the copyright notices should be gone by now, but if you come across one
+in the rust-lang/rust repo, feel free to open a PR to remove it.
+
+## Line length
+
+Lines should be at most 100 characters. It's even better if you can
+keep things to 80.
+
+**Ignoring the line length limit.** Sometimes – in particular for
+tests – it can be necessary to exempt yourself from this limit. In
+that case, you can add a comment towards the top of the file like so:
+
+```rust
+// ignore-tidy-linelength
+```
+
+## Tabs vs spaces
+
+Prefer 4-space indent.
+
+<a name="cc"></a>
+
+# Coding for correctness
+
+Beyond formatting, there are a few other tips that are worth
+following.
+
+## Prefer exhaustive matches
+
+Using `_` in a match is convenient, but it means that when new
+variants are added to the enum, they may not get handled correctly.
+Ask yourself: if a new variant were added to this enum, what's the
+chance that it would want to use the `_` code, versus having some
+other treatment?  Unless the answer is "low", then prefer an
+exhaustive match. (The same advice applies to `if let` and `while
+let`, which are effectively tests for a single variant.)
+
+## Use "TODO" comments for things you don't want to forget
+
+As a useful tool to yourself, you can insert a `// TODO` comment
+for something that you want to get back to before you land your PR:
+
+```rust,ignore
+fn do_something() {
+    if something_else {
+        unimplemented!(); // TODO write this
+    }
+}
+```
+
+The tidy script will report an error for a `// TODO` comment, so this
+code would not be able to land until the TODO is fixed (or removed).
+
+This can also be useful in a PR as a way to signal from one commit that you are
+leaving a bug that a later commit will fix:
+
+```rust,ignore
+if foo {
+    return true; // TODO wrong, but will be fixed in a later commit
+}
+```
+
+<a name="cio"></a>
+
+# Using crates from crates.io
+
+See the [crates.io dependencies][crates] section.
+
+<a name="er"></a>
+
+# How to structure your PR
+
+How you prepare the commits in your PR can make a big difference for the
+reviewer.  Here are some tips.
+
+**Isolate "pure refactorings" into their own commit.** For example, if
+you rename a method, then put that rename into its own commit, along
+with the renames of all the uses.
+
+**More commits is usually better.** If you are doing a large change,
+it's almost always better to break it up into smaller steps that can
+be independently understood. The one thing to be aware of is that if
+you introduce some code following one strategy, then change it
+dramatically (versus adding to it) in a later commit, that
+'back-and-forth' can be confusing.
+
+**Format liberally.** While only the final commit of a PR must be correctly
+formatted, it is both easier to review and less noisy to format each commit
+individually using `./x.py fmt`.
+
+**No merges.** We do not allow merge commits into our history, other
+than those by bors. If you get a merge conflict, rebase instead via a
+command like `git rebase -i rust-lang/master` (presuming you use the
+name `rust-lang` for your remote).
+
+**Individual commits do not have to build (but it's nice).** We do not
+require that every intermediate commit successfully builds – we only
+expect to be able to bisect at a PR level. However, if you *can* make
+individual commits build, that is always helpful.
+
+# Naming conventions
+
+Apart from normal Rust style/naming conventions, there are also some specific
+to the compiler.
+
+- `cx` tends to be short for "context" and is often used as a suffix. For
+  example, `tcx` is a common name for the [Typing Context][tcx].
+
+- [`'tcx`][tcx] is used as the lifetime name for the Typing Context.
+
+- Because `crate` is a keyword, if you need a variable to represent something
+  crate-related, often the spelling is changed to `krate`.
+
+[tcx]: ./ty.md
+[crates]: ./crates-io.md
diff --git a/src/doc/rustc-dev-guide/src/crates-io.md b/src/doc/rustc-dev-guide/src/crates-io.md
new file mode 100644
index 000000000..8c8fd0c38
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/crates-io.md
@@ -0,0 +1,24 @@
+# crates.io Dependencies
+
+The Rust compiler supports building with some dependencies from `crates.io`.
+For example, `log` and `env_logger` come from `crates.io`.
+
+In general, you should avoid adding dependencies to the compiler for several
+reasons:
+
+- The dependency may not be high quality or well-maintained, whereas we want
+  the compiler to be high-quality.
+- The dependency may not be using a compatible license.
+- The dependency may have transitive dependencies that have one of the above
+  problems.
+
+As of <!-- date: 2022-02 --> February 2022, there is no official policy for vetting
+new dependencies to the compiler. Generally, new dependencies are not added
+to the compiler unless there is a good reason to do so.
+
+## Permitted dependencies
+
+The `tidy` tool has [a list of crates that are allowed]. To add a
+dependency that is not already in the compiler, you will need to add it to the list.
+
+[a list of crates that are allowed]: https://github.com/rust-lang/rust/blob/9d1b2106e23b1abd32fce1f17267604a5102f57a/src/tools/tidy/src/deps.rs#L73
diff --git a/src/doc/rustc-dev-guide/src/debugging-support-in-rustc.md b/src/doc/rustc-dev-guide/src/debugging-support-in-rustc.md
new file mode 100644
index 000000000..932b23b92
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/debugging-support-in-rustc.md
@@ -0,0 +1,354 @@
+# Debugging support in the Rust compiler
+
+<!-- toc -->
+
+This document explains the state of debugging tools support in the Rust compiler (rustc).
+It gives an overview of GDB, LLDB, WinDbg/CDB,
+as well as infrastructure around Rust compiler to debug Rust code.
+If you want to learn how to debug the Rust compiler itself,
+see [Debugging the Compiler].
+
+The material is gathered from the video,
+[Tom Tromey discusses debugging support in rustc].
+
+## Preliminaries
+
+### Debuggers
+
+According to Wikipedia
+
+> A [debugger or debugging tool] is a computer program that is used to test and debug
+> other programs (the "target" program).
+
+Writing a debugger from scratch for a language requires a lot of work, especially if
+debuggers have to be supported on various platforms. GDB and LLDB, however, can be
+extended to support debugging a language. This is the path that Rust has chosen.
+This document's main goal is to document the said debuggers support in Rust compiler.
+
+### DWARF
+
+According to the [DWARF] standard website
+
+> DWARF is a debugging file format used by many compilers and debuggers to support source level
+> debugging. It addresses the requirements of a number of procedural languages,
+> such as C, C++, and Fortran, and is designed to be extensible to other languages.
+> DWARF is architecture independent and applicable to any processor or operating system.
+> It is widely used on Unix, Linux and other operating systems,
+> as well as in stand-alone environments.
+
+DWARF reader is a program that consumes the DWARF format and creates debugger compatible output.
+This program may live in the compiler itself.  DWARF uses a data structure called
+Debugging Information Entry (DIE) which stores the information as "tags" to denote functions,
+variables etc., e.g., `DW_TAG_variable`, `DW_TAG_pointer_type`, `DW_TAG_subprogram` etc.
+You can also invent your own tags and attributes.
+
+### CodeView/PDB
+
+[PDB] (Program Database) is a file format created by Microsoft that contains debug information.
+PDBs can be consumed by debuggers such as WinDbg/CDB and other tools to display debug information.
+A PDB contains multiple streams that describe debug information about a specific binary such
+as types, symbols, and source files used to compile the given binary. CodeView is another
+format which defines the structure of [symbol records] and [type records] that appear within
+PDB streams.
+
+## Supported debuggers
+
+### GDB
+
+#### Rust expression parser
+
+To be able to show debug output, we need an expression parser.
+This (GDB) expression parser is written in [Bison],
+and can parse only a subset of Rust expressions.
+GDB parser was written from scratch and has no relation to any other parser,
+including that of rustc.
+
+GDB has Rust-like value and type output. It can print values and types in a way
+that look like Rust syntax in the output. Or when you print a type as [ptype] in GDB,
+it also looks like Rust source code. Checkout the documentation in the [manual for GDB/Rust].
+
+#### Parser extensions
+
+Expression parser has a couple of extensions in it to facilitate features that you cannot do
+with Rust. Some limitations are listed in the [manual for GDB/Rust]. There is some special
+code in the DWARF reader in GDB to support the extensions.
+
+A couple of examples of DWARF reader support needed are as follows:
+
+1. Enum: Needed for support for enum types.
+   The Rust compiler writes the information about enum into DWARF,
+   and GDB reads the DWARF to understand where is the tag field,
+   or if there is a tag field,
+   or if the tag slot is shared with non-zero optimization etc.
+
+2. Dissect trait objects: DWARF extension where the trait object's description in the DWARF
+   also points to a stub description of the corresponding vtable which in turn points to the
+   concrete type for which this trait object exists. This means that you can do a `print *object`
+   for that trait object, and GDB will understand how to find the correct type of the payload in
+   the trait object.
+
+**TODO**: Figure out if the following should be mentioned in the GDB-Rust document rather than
+this guide page so there is no duplication. This is regarding the following comments:
+
+[This comment by Tom](https://github.com/rust-lang/rustc-dev-guide/pull/316#discussion_r284027340)
+> gdb's Rust extensions and limitations are documented in the gdb manual:
+https://sourceware.org/gdb/onlinedocs/gdb/Rust.html -- however, this neglects to mention that
+gdb convenience variables and registers follow the gdb $ convention, and that the Rust parser
+implements the gdb @ extension.
+
+[This question by Aman](https://github.com/rust-lang/rustc-dev-guide/pull/316#discussion_r285401353)
+> @tromey do you think we should mention this part in the GDB-Rust document rather than this
+document so there is no duplication etc.?
+
+### LLDB
+
+#### Rust expression parser
+
+This expression parser is written in C++. It is a type of [Recursive Descent parser].
+It implements slightly less of the Rust language than GDB.
+LLDB has Rust-like value and type output.
+
+#### Developer notes
+
+* LLDB has a plugin architecture but that does not work for language support.
+* GDB generally works better on Linux.
+
+### WinDbg/CDB
+
+Microsoft provides [Windows Debugging Tools] such as the Windows Debugger (WinDbg) and
+the Console Debugger (CDB) which both support debugging programs written in Rust. These
+debuggers parse the debug info for a binary from the `PDB`, if available, to construct a
+visualization to serve up in the debugger.
+
+#### Natvis
+
+Both WinDbg and CDB support defining and viewing custom visualizations for any given type
+within the debugger using the Natvis framework. The Rust compiler defines a set of Natvis
+files that define custom visualizations for a subset of types in the standard libraries such
+as, `std`, `core`, and `alloc`. These Natvis files are embedded into `PDBs` generated by the
+`*-pc-windows-msvc` target triples to automatically enable these custom visualizations when
+debugging. This default can be overridden by setting the `strip` rustc flag to either `debuginfo`
+or `symbols`.
+
+Rust has support for embedding Natvis files for crates outside of the standard libraries by
+using the `#[debugger_visualizer]` attribute.
+For more details on how to embed debugger visualizers,
+please refer to the `#[debugger_visualizer]` attribute in
+[the unstable book](https://doc.rust-lang.org/unstable-book/language-features/debugger-visualizer.html).
+
+## DWARF and `rustc`
+
+[DWARF] is the standard way compilers generate debugging information that debuggers read.
+It is _the_ debugging format on macOS and Linux.
+It is a multi-language and extensible format,
+and is mostly good enough for Rust's purposes.
+Hence, the current implementation reuses DWARF's concepts.
+This is true even if some of the concepts in DWARF do not align with Rust semantically because,
+generally, there can be some kind of mapping between the two.
+
+We have some DWARF extensions that the Rust compiler emits and the debuggers understand that
+are _not_ in the DWARF standard.
+
+* Rust compiler will emit DWARF for a virtual table, and this `vtable` object will have a
+  `DW_AT_containing_type` that points to the real type. This lets debuggers dissect a trait object
+   pointer to correctly find the payload. E.g., here's such a DIE, from a test case in the gdb
+   repository:
+
+   ```asm
+   <1><1a9>: Abbrev Number: 3 (DW_TAG_structure_type)
+      <1aa>   DW_AT_containing_type: <0x1b4>
+      <1ae>   DW_AT_name        : (indirect string, offset: 0x23d): vtable
+      <1b2>   DW_AT_byte_size   : 0
+      <1b3>   DW_AT_alignment   : 8
+   ```
+
+* The other extension is that the Rust compiler can emit a tagless discriminated union.
+  See [DWARF feature request] for this item.
+
+### Current limitations of DWARF
+
+* Traits - require a bigger change than normal to DWARF, on how to represent Traits in DWARF.
+* DWARF provides no way to differentiate between Structs and Tuples. Rust compiler emits
+fields with `__0` and debuggers look for a sequence of such names to overcome this limitation.
+For example, in this case the debugger would look at a field via `x.__0` instead of `x.0`.
+This is resolved via the Rust parser in the debugger so now you can do `x.0`.
+
+DWARF relies on debuggers to know some information about platform ABI.
+Rust does not do that all the time.
+
+## Developer notes
+
+This section is from the talk about certain aspects of development.
+
+## What is missing
+
+### Code signing for LLDB debug server on macOS
+
+According to Wikipedia, [System Integrity Protection] is
+
+> System Integrity Protection (SIP, sometimes referred to as rootless) is a security feature
+> of Apple's macOS operating system introduced in OS X El Capitan. It comprises a number of
+> mechanisms that are enforced by the kernel. A centerpiece is the protection of system-owned
+> files and directories against modifications by processes without a specific "entitlement",
+> even when executed by the root user or a user with root privileges (sudo).
+
+It prevents processes using `ptrace` syscall. If a process wants to use `ptrace` it has to be
+code signed. The certificate that signs it has to be trusted on your machine.
+
+See [Apple developer documentation for System Integrity Protection].
+
+We may need to sign up with Apple and get the keys to do this signing. Tom has looked into if
+Mozilla cannot do this because it is at the maximum number of
+keys it is allowed to sign. Tom does not know if Mozilla could get more keys.
+
+Alternatively, Tom suggests that maybe a Rust legal entity is needed to get the keys via Apple.
+This problem is not technical in nature. If we had such a key we could sign GDB as well and
+ship that.
+
+### DWARF and Traits
+
+Rust traits are not emitted into DWARF at all. The impact of this is calling a method `x.method()`
+does not work as is. The reason being that method is implemented by a trait, as opposed
+to a type. That information is not present so finding trait methods is missing.
+
+DWARF has a notion of interface types (possibly added for Java). Tom's idea was to use this
+interface type as traits.
+
+DWARF only deals with concrete names, not the reference types. So, a given implementation of a
+trait for a type would be one of these interfaces (`DW_tag_interface` type). Also, the type for
+which it is implemented would describe all the interfaces this type implements. This requires a
+DWARF extension.
+
+Issue on Github: [https://github.com/rust-lang/rust/issues/33014]
+
+## Typical process for a Debug Info change (LLVM)
+
+LLVM has Debug Info (DI) builders. This is the primary thing that Rust calls into.
+This is why we need to change LLVM first because that is emitted first and not DWARF directly.
+This is a kind of metadata that you construct and hand-off to LLVM. For the Rustc/LLVM hand-off
+some LLVM DI builder methods are called to construct representation of a type.
+
+The steps of this process are as follows:
+
+1. LLVM needs changing.
+
+   LLVM does not emit Interface types at all, so this needs to be implemented in the LLVM first.
+
+   Get sign off on LLVM maintainers that this is a good idea.
+
+2. Change the DWARF extension.
+
+3. Update the debuggers.
+
+   Update DWARF readers, expression evaluators.
+
+4. Update Rust compiler.
+
+   Change it to emit this new information.
+
+### Procedural macro stepping
+
+A deeply profound question is that how do you actually debug a procedural macro?
+What is the location you emit for a macro expansion? Consider some of the following cases -
+
+* You can emit location of the invocation of the macro.
+* You can emit the location of the definition of the macro.
+* You can emit locations of the content of the macro.
+
+RFC: [https://github.com/rust-lang/rfcs/pull/2117]
+
+Focus is to let macros decide what to do. This can be achieved by having some kind of attribute
+that lets the macro tell the compiler where the line marker should be. This affects where you
+set the breakpoints and what happens when you step it.
+
+## Source file checksums in debug info
+
+Both DWARF and CodeView (PDB) support embedding a cryptographic hash of each source file that
+contributed to the associated binary.
+
+The cryptographic hash can be used by a debugger to verify that the source file matches the
+executable. If the source file does not match, the debugger can provide a warning to the user.
+
+The hash can also be used to prove that a given source file has not been modified since it was
+used to compile an executable. Because MD5 and SHA1 both have demonstrated vulnerabilities,
+using SHA256 is recommended for this application.
+
+The Rust compiler stores the hash for each source file in the corresponding `SourceFile` in
+the `SourceMap`. The hashes of input files to external crates are stored in `rlib` metadata.
+
+A default hashing algorithm is set in the target specification. This allows the target to
+specify the best hash available, since not all targets support all hash algorithms.
+
+The hashing algorithm for a target can also be overridden with the `-Z source-file-checksum=`
+command-line option.
+
+#### DWARF 5
+DWARF version 5 supports embedding an MD5 hash to validate the source file version in use.
+DWARF 5 - Section 6.2.4.1 opcode DW_LNCT_MD5
+
+#### LLVM
+LLVM IR supports MD5 and SHA1 (and SHA256 in LLVM 11+) source file checksums in the DIFile node.
+
+[LLVM DIFile documentation](https://llvm.org/docs/LangRef.html#difile)
+
+#### Microsoft Visual C++ Compiler /ZH option
+The MSVC compiler supports embedding MD5, SHA1, or SHA256 hashes in the PDB using the `/ZH`
+compiler option.
+
+[MSVC /ZH documentation](https://docs.microsoft.com/en-us/cpp/build/reference/zh)
+
+#### Clang
+Clang always embeds an MD5 checksum, though this does not appear in documentation.
+
+## Future work
+
+#### Name mangling changes
+
+* New demangler in `libiberty` (gcc source tree).
+* New demangler in LLVM or LLDB.
+
+**TODO**: Check the location of the demangler source. [#1157](https://github.com/rust-lang/rustc-dev-guide/issues/1157)
+
+#### Reuse Rust compiler for expressions
+
+This is an important idea because debuggers by and large do not try to implement type
+inference. You need to be much more explicit when you type into the debugger than your
+actual source code. So, you cannot just copy and paste an expression from your source
+code to debugger and expect the same answer but this would be nice. This can be helped
+by using compiler.
+
+It is certainly doable but it is a large project. You certainly need a bridge to the
+debugger because the debugger alone has access to the memory. Both GDB (gcc) and LLDB (clang)
+have this feature. LLDB uses Clang to compile code to JIT and GDB can do the same with GCC.
+
+Both debuggers expression evaluation implement both a superset and a subset of Rust.
+They implement just the expression language,
+but they also add some extensions like GDB has convenience variables.
+Therefore, if you are taking this route,
+then you not only need to do this bridge,
+but may have to add some mode to let the compiler understand some extensions.
+
+[Tom Tromey discusses debugging support in rustc]: https://www.youtube.com/watch?v=elBxMRSNYr4
+[Debugging the Compiler]: compiler-debugging.md
+[debugger or debugging tool]: https://en.wikipedia.org/wiki/Debugger
+[Bison]: https://www.gnu.org/software/bison/
+[ptype]: https://ftp.gnu.org/old-gnu/Manuals/gdb/html_node/gdb_109.html
+[rust-lang/lldb wiki page]: https://github.com/rust-lang/lldb/wiki
+[DWARF]: http://dwarfstd.org
+[manual for GDB/Rust]: https://sourceware.org/gdb/onlinedocs/gdb/Rust.html
+[GDB Bugzilla]: https://sourceware.org/bugzilla/
+[Recursive Descent parser]: https://en.wikipedia.org/wiki/Recursive_descent_parser
+[System Integrity Protection]: https://en.wikipedia.org/wiki/System_Integrity_Protection
+[https://github.com/rust-dev-tools/gdb]: https://github.com/rust-dev-tools/gdb
+[DWARF feature request]: http://dwarfstd.org/ShowIssue.php?issue=180517.2
+[https://docs.python.org/3/c-api/stable.html]: https://docs.python.org/3/c-api/stable.html
+[https://github.com/rust-lang/rfcs/pull/2117]: https://github.com/rust-lang/rfcs/pull/2117
+[https://github.com/rust-lang/rust/issues/33014]: https://github.com/rust-lang/rust/issues/33014
+[https://github.com/rust-lang/rust/issues/34457]: https://github.com/rust-lang/rust/issues/34457
+[Apple developer documentation for System Integrity Protection]: https://developer.apple.com/library/archive/releasenotes/MacOSX/WhatsNewInOSX/Articles/MacOSX10_11.html#//apple_ref/doc/uid/TP40016227-SW11
+[https://github.com/rust-lang/lldb]: https://github.com/rust-lang/lldb
+[https://github.com/rust-lang/llvm-project]: https://github.com/rust-lang/llvm-project
+[PDB]: https://llvm.org/docs/PDB/index.html
+[symbol records]: https://llvm.org/docs/PDB/CodeViewSymbols.html
+[type records]: https://llvm.org/docs/PDB/CodeViewTypes.html
+[Windows Debugging Tools]: https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/
diff --git a/src/doc/rustc-dev-guide/src/diagnostics.md b/src/doc/rustc-dev-guide/src/diagnostics.md
new file mode 100644
index 000000000..0f0bfd895
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics.md
@@ -0,0 +1,936 @@
+# Errors and Lints
+
+<!-- toc -->
+
+A lot of effort has been put into making `rustc` have great error messages.
+This chapter is about how to emit compile errors and lints from the compiler.
+
+## Diagnostic structure
+
+The main parts of a diagnostic error are the following:
+
+```
+error[E0000]: main error message
+  --> file.rs:LL:CC
+   |
+LL | <code>
+   | -^^^^- secondary label
+   |  |
+   |  primary label
+   |
+   = note: note without a `Span`, created with `.note`
+note: sub-diagnostic message for `.span_note`
+  --> file.rs:LL:CC
+   |
+LL | more code
+   |      ^^^^
+```
+
+- Level (`error`, `warning`, etc.). It indicates the severity of the message.
+  (See [diagnostic levels](#diagnostic-levels))
+- Code (for example, for "mismatched types", it is `E0308`). It helps
+  users get more information about the current error through an extended
+  description of the problem in the error code index. Diagnostics created
+  by lints don't have a code in the emitted message.
+- Message. It is the main description of the problem. It should be general and
+  able to stand on its own, so that it can make sense even in isolation.
+- Diagnostic window. This contains several things:
+  - The path, line number and column of the beginning of the primary span.
+  - The users' affected code and its surroundings.
+  - Primary and secondary spans underlying the users' code. These spans can
+    optionally contain one or more labels.
+    - Primary spans should have enough text to describe the problem in such a
+      way that if it were the only thing being displayed (for example, in an
+      IDE) it would still make sense. Because it is "spatially aware" (it
+      points at the code), it can generally be more succinct than the error
+      message.
+    - If cluttered output can be foreseen in cases when multiple span labels
+      overlap, it is a good idea to tweak the output appropriately. For
+      example, the `if/else arms have incompatible types` error uses different
+      spans depending on whether the arms are all in the same line, if one of
+      the arms is empty and if none of those cases applies.
+- Sub-diagnostics. Any error can have multiple sub-diagnostics that look
+  similar to the main part of the error. These are used for cases where the
+  order of the explanation might not correspond with the order of the code. If
+  the order of the explanation can be "order free", leveraging secondary labels
+  in the main diagnostic is preferred, as it is typically less verbose.
+
+The text should be matter of fact and avoid capitalization and periods, unless
+multiple sentences are _needed_:
+
+```txt
+error: the fobrulator needs to be krontrificated
+```
+
+When code or an identifier must appear in a message or label, it should be
+surrounded with backticks:
+
+```txt
+error: the identifier `foo.bar` is invalid
+```
+
+### Error explanations
+
+Some errors include long form descriptions. They may be viewed with the
+`--explain` flag, or via the [error index]. Each explanation comes with an
+example of how to trigger it and advice on how to fix it.
+
+Please read [RFC 1567] for details on how to format and write long error
+codes.
+
+The descriptions are written in Markdown, and all of them are linked in the
+[`rustc_error_codes`] crate.
+
+As a general rule, give an error a code (with an associated explanation) if the
+explanation would give more information than the error itself. A lot of the time
+it's better to put all the information in the emitted error itself. However,
+sometimes that would make the error verbose or there are too many possible
+triggers to include useful information for all cases in the error, in which case
+it's a good idea to add an explanation.[^estebank]
+As always, if you are not sure, just ask your reviewer!
+
+[^estebank]: This rule of thumb was suggested by **@estebank** [here][estebank-comment].
+
+[`rustc_error_codes`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_error_codes/error_codes/index.html
+[error index]: https://doc.rust-lang.org/error-index.html
+[RFC 1567]: https://github.com/rust-lang/rfcs/blob/master/text/1567-long-error-codes-explanation-normalization.md
+[estebank-comment]: https://github.com/rust-lang/rustc-dev-guide/pull/967#issuecomment-733218283
+
+### Lints versus fixed diagnostics
+
+Some messages are emitted via [lints](#lints), where the user can control the
+level. Most diagnostics are hard-coded such that the user cannot control the
+level.
+
+Usually it is obvious whether a diagnostic should be "fixed" or a lint, but
+there are some grey areas.
+
+Here are a few examples:
+
+- Borrow checker errors: these are fixed errors. The user cannot adjust the
+  level of these diagnostics to silence the borrow checker.
+- Dead code: this is a lint. While the user probably doesn't want dead code in
+  their crate, making this a hard error would make refactoring and development
+  very painful.
+- [safe_packed_borrows future compatibility warning][safe_packed_borrows]:
+  this is a silencable lint related to safety. It was judged that the making
+  this a hard (fixed) error would cause too much breakage, so instead a
+  warning is emitted that eventually will be turned into a hard error.
+
+Hard-coded warnings (those using the `span_warn` methods) should be avoided
+for normal code, preferring to use lints instead. Some cases, such as warnings
+with CLI flags, will require the use of hard-coded warnings.
+
+See the `deny` [lint level](#diagnostic-levels) below for guidelines when to
+use an error-level lint instead of a fixed error.
+
+[safe_packed_borrows]: https://github.com/rust-lang/rust/issues/46043
+
+## Diagnostic output style guide
+
+- Write in plain simple English. If your message, when shown on a – possibly
+  small – screen (which hasn't been cleaned for a while), cannot be understood
+  by a normal programmer, who just came out of bed after a night partying,
+  it's too complex.
+- `Error`, `Warning`, `Note`, and `Help` messages start with a lowercase
+  letter and do not end with punctuation.
+- Error messages should be succinct. Users will see these error messages many
+  times, and more verbose descriptions can be viewed with the `--explain`
+  flag. That said, don't make it so terse that it's hard to understand.
+- The word "illegal" is illegal. Prefer "invalid" or a more specific word
+  instead.
+- Errors should document the span of code where they occur (use
+  [`rustc_errors::diagnostic_builder::DiagnosticBuilder`][diagbuild]'s
+  `span_*` methods or a diagnostic struct's `#[primary_span]` to easily do
+  this). Also `note` other spans that have contributed to the error if the span
+  isn't too large.
+- When emitting a message with span, try to reduce the span to the smallest
+  amount possible that still signifies the issue
+- Try not to emit multiple error messages for the same error. This may require
+  detecting duplicates.
+- When the compiler has too little information for a specific error message,
+  consult with the compiler team to add new attributes for library code that
+  allow adding more information. For example see
+  [`#[rustc_on_unimplemented]`](#rustc_on_unimplemented). Use these
+  annotations when available!
+- Keep in mind that Rust's learning curve is rather steep, and that the
+  compiler messages are an important learning tool.
+- When talking about the compiler, call it `the compiler`, not `Rust` or
+  `rustc`.
+
+### Lint naming
+
+From [RFC 0344], lint names should be consistent, with the following
+guidelines:
+
+The basic rule is: the lint name should make sense when read as "allow
+*lint-name*" or "allow *lint-name* items". For example, "allow
+`deprecated` items" and "allow `dead_code`" makes sense, while "allow
+`unsafe_block`" is ungrammatical (should be plural).
+
+- Lint names should state the bad thing being checked for, e.g. `deprecated`,
+  so that `#[allow(deprecated)]` (items) reads correctly. Thus `ctypes` is not
+  an appropriate name; `improper_ctypes` is.
+
+- Lints that apply to arbitrary items (like the stability lints) should just
+  mention what they check for: use `deprecated` rather than
+  `deprecated_items`. This keeps lint names short. (Again, think "allow
+  *lint-name* items".)
+
+- If a lint applies to a specific grammatical class, mention that class and
+  use the plural form: use `unused_variables` rather than `unused_variable`.
+  This makes `#[allow(unused_variables)]` read correctly.
+
+- Lints that catch unnecessary, unused, or useless aspects of code should use
+  the term `unused`, e.g. `unused_imports`, `unused_typecasts`.
+
+- Use snake case in the same way you would for function names.
+
+[RFC 0344]: https://github.com/rust-lang/rfcs/blob/master/text/0344-conventions-galore.md#lints
+
+### Diagnostic levels
+
+Guidelines for different diagnostic levels:
+
+- `error`: emitted when the compiler detects a problem that makes it unable to
+  compile the program, either because the program is invalid or the programmer
+  has decided to make a specific `warning` into an error.
+
+- `warning`: emitted when the compiler detects something odd about a program.
+  Care should be taken when adding warnings to avoid warning fatigue, and
+  avoid false-positives where there really isn't a problem with the code. Some
+  examples of when it is appropriate to issue a warning:
+
+  - A situation where the user *should* take action, such as swap out a
+    deprecated item, or use a `Result`, but otherwise doesn't prevent
+    compilation.
+  - Unnecessary syntax that can be removed without affecting the semantics of
+    the code. For example, unused code, or unnecessary `unsafe`.
+  - Code that is very likely to be incorrect, dangerous, or confusing, but the
+    language technically allows, and is not ready or confident enough to make
+    an error. For example `unused_comparisons` (out of bounds comparisons) or
+    `bindings_with_variant_name` (the user likely did not intend to create a
+    binding in a pattern).
+  - [Future-incompatible lints](#future-incompatible), where something was
+    accidentally or erroneously accepted in the past, but rejecting would
+    cause excessive breakage in the ecosystem.
+  - Stylistic choices. For example, camel or snake case, or the `dyn` trait
+    warning in the 2018 edition. These have a high bar to be added, and should
+    only be used in exceptional circumstances. Other stylistic choices should
+    either be allow-by-default lints, or part of other tools like Clippy or
+    rustfmt.
+
+- `help`: emitted following an `error` or `warning` to give additional
+  information to the user about how to solve their problem. These messages
+  often include a suggestion string and [`rustc_errors::Applicability`]
+  confidence level to guide automated source fixes by tools. See the
+  [Suggestions](#suggestions) section for more details.
+
+  The error or warning portion should *not* suggest how to fix the problem,
+  only the "help" sub-diagnostic should.
+
+- `note`: emitted to given more context and identify additional circumstances
+  and parts of the code that caused the warning or error. For example, the
+  borrow checker will note any previous conflicting borrows.
+
+  `help` vs `note`: `help` should be used to show changes the user can
+  possibly make to fix the problem. `note` should be used for everything else,
+  such as other context, information and facts, online resources to read, etc.
+
+Not to be confused with *lint levels*, whose guidelines are:
+
+- `forbid`: Lints should never default to `forbid`.
+- `deny`: Equivalent to `error` diagnostic level. Some examples:
+
+  - A future-incompatible or edition-based lint that has graduated from the
+    warning level.
+  - Something that has an extremely high confidence that is incorrect, but
+    still want an escape hatch to allow it to pass.
+
+- `warn`: Equivalent to the `warning` diagnostic level. See `warning` above
+  for guidelines.
+- `allow`: Examples of the kinds of lints that should default to `allow`:
+
+  - The lint has a too high false positive rate.
+  - The lint is too opinionated.
+  - The lint is experimental.
+  - The lint is used for enforcing something that is not normally enforced.
+    For example, the `unsafe_code` lint can be used to prevent usage of unsafe
+    code.
+
+More information about lint levels can be found in the [rustc
+book][rustc-lint-levels] and the [reference][reference-diagnostics].
+
+[`rustc_errors::Applicability`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/enum.Applicability.html
+[reference-diagnostics]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#lint-check-attributes
+[rustc-lint-levels]: https://doc.rust-lang.org/nightly/rustc/lints/levels.html
+
+## Helpful tips and options
+
+### Finding the source of errors
+
+There are two main ways to find where a given error is emitted:
+
+- `grep` for either a sub-part of the error message/label or error code. This
+  usually works well and is straightforward, but there are some cases where
+  the code emitting the error is removed from the code where the error is
+  constructed behind a relatively deep call-stack. Even then, it is a good way
+  to get your bearings.
+- Invoking `rustc` with the nightly-only flag `-Z treat-err-as-bug=1`
+  will treat the first error being emitted as an Internal Compiler Error, which
+  allows you to get a
+  stack trace at the point the error has been emitted. Change the `1` to
+  something else if you wish to trigger on a later error.
+
+  There are limitations with this approach:
+  - Some calls get elided from the stack trace because they get inlined in the compiled `rustc`.
+  - The _construction_ of the error is far away from where it is _emitted_,
+    a problem similar to the one we faced with the `grep` approach.
+    In some cases, we buffer multiple errors in order to emit them in order.
+
+The regular development practices apply: judicious use of `debug!()` statements
+and use of a debugger to trigger break points in order to figure out in what
+order things are happening.
+
+## `Span`
+
+[`Span`][span] is the primary data structure in `rustc` used to represent a
+location in the code being compiled. `Span`s are attached to most constructs in
+HIR and MIR, allowing for more informative error reporting.
+
+[span]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html
+
+A `Span` can be looked up in a [`SourceMap`][sourcemap] to get a "snippet"
+useful for displaying errors with [`span_to_snippet`][sptosnip] and other
+similar methods on the `SourceMap`.
+
+[sourcemap]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/source_map/struct.SourceMap.html
+[sptosnip]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/source_map/struct.SourceMap.html#method.span_to_snippet
+
+## Error messages
+
+The [`rustc_errors`][errors] crate defines most of the utilities used for
+reporting errors.
+
+[errors]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/index.html
+
+Diagnostics can be implemented as types which implement the `SessionDiagnostic`
+trait. This is preferred for new diagnostics as it enforces a separation
+between diagnostic emitting logic and the main code paths. For less-complex
+diagnostics, the `SessionDiagnostic` trait can be derived -- see [Diagnostic
+structs][diagnostic-structs]. Within the trait implementation, the APIs
+described below can be used as normal.
+
+[diagnostic-structs]: ./diagnostics/diagnostic-structs.md
+
+[`Session`][session] and [`ParseSess`][parsesses] have
+methods (or fields with methods) that allow reporting errors. These methods
+usually have names like `span_err` or `struct_span_err` or `span_warn`, etc...
+There are lots of them; they emit different types of "errors", such as
+warnings, errors, fatal errors, suggestions, etc.
+
+[parsesses]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/parse/struct.ParseSess.html
+[session]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html
+
+In general, there are two classes of such methods: ones that emit an error
+directly and ones that allow finer control over what to emit. For example,
+[`span_err`][spanerr] emits the given error message at the given `Span`, but
+[`struct_span_err`][strspanerr] instead returns a
+[`DiagnosticBuilder`][diagbuild].
+
+Most of these methods will accept strings, but it is recommended that typed
+identifiers for translatable diagnostics be used for new diagnostics (see
+[Translation][translation]).
+
+[translation]: ./diagnostics/translation.md
+
+`DiagnosticBuilder` allows you to add related notes and suggestions to an error
+before emitting it by calling the [`emit`][emit] method. (Failing to either
+emit or [cancel][cancel] a `DiagnosticBuilder` will result in an ICE.) See the
+[docs][diagbuild] for more info on what you can do.
+
+[spanerr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html#method.span_err
+[strspanerr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html#method.struct_span_err
+[diagbuild]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/diagnostic_builder/struct.DiagnosticBuilder.html
+[emit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/diagnostic_builder/struct.DiagnosticBuilder.html#method.emit
+[cancel]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Diagnostic.html#method.cancel
+
+```rust,ignore
+// Get a DiagnosticBuilder. This does _not_ emit an error yet.
+let mut err = sess.struct_span_err(sp, fluent::example::example_error);
+
+// In some cases, you might need to check if `sp` is generated by a macro to
+// avoid printing weird errors about macro-generated code.
+
+if let Ok(snippet) = sess.source_map().span_to_snippet(sp) {
+    // Use the snippet to generate a suggested fix
+    err.span_suggestion(suggestion_sp, fluent::example::try_qux_suggestion, format!("qux {}", snippet));
+} else {
+    // If we weren't able to generate a snippet, then emit a "help" message
+    // instead of a concrete "suggestion". In practice this is unlikely to be
+    // reached.
+    err.span_help(suggestion_sp, fluent::example::qux_suggestion);
+}
+
+// emit the error
+err.emit();
+```
+
+```fluent
+example-example-error = oh no! this is an error!
+  .try-qux-suggestion = try using a qux here
+  .qux-suggestion = you could use a qux here instead
+```
+
+## Suggestions
+
+In addition to telling the user exactly _why_ their code is wrong, it's
+oftentimes furthermore possible to tell them how to fix it. To this end,
+`DiagnosticBuilder` offers a structured suggestions API, which formats code
+suggestions pleasingly in the terminal, or (when the `--error-format json` flag
+is passed) as JSON for consumption by tools, most notably the [Rust Language
+Server][rls] and [`rustfix`][rustfix].
+
+[rls]: https://github.com/rust-lang/rls
+[rustfix]: https://github.com/rust-lang/rustfix
+
+Not all suggestions should be applied mechanically, they have a degree of
+confidence in the suggested code, from high
+(`Applicability::MachineApplicable`) to low (`Applicability::MaybeIncorrect`).
+Be conservative when choosing the level. Use the
+[`span_suggestion`][span_suggestion] method of `DiagnosticBuilder` to
+make a suggestion. The last argument provides a hint to tools whether
+the suggestion is mechanically applicable or not.
+
+Suggestions point to one or more spans with corresponding code that will
+replace their current content.
+
+The message that accompanies them should be understandable in the following
+contexts:
+
+- shown as an independent sub-diagnostic (this is the default output)
+- shown as a label pointing at the affected span (this is done automatically if
+some heuristics for verbosity are met)
+- shown as a `help` sub-diagnostic with no content (used for cases where the
+suggestion is obvious from the text, but we still want to let tools to apply
+them))
+- not shown (used for _very_ obvious cases, but we still want to allow tools to
+apply them)
+
+[span_suggestion]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.DiagnosticBuilder.html#method.span_suggestion
+
+For example, to make our `qux` suggestion machine-applicable, we would do:
+
+```rust,ignore
+let mut err = sess.struct_span_err(sp, fluent::example::message);
+
+if let Ok(snippet) = sess.source_map().span_to_snippet(sp) {
+    err.span_suggestion(
+        suggestion_sp,
+        fluent::example::try_qux_suggestion,
+        format!("qux {}", snippet),
+        Applicability::MachineApplicable,
+    );
+} else {
+    err.span_help(suggestion_sp, fluent::example::qux_suggestion);
+}
+
+err.emit();
+```
+
+This might emit an error like
+
+```console
+$ rustc mycode.rs
+error[E0999]: oh no! this is an error!
+ --> mycode.rs:3:5
+  |
+3 |     sad()
+  |     ^ help: try using a qux here: `qux sad()`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0999`.
+```
+
+In some cases, like when the suggestion spans multiple lines or when there are
+multiple suggestions, the suggestions are displayed on their own:
+
+```console
+error[E0999]: oh no! this is an error!
+ --> mycode.rs:3:5
+  |
+3 |     sad()
+  |     ^
+help: try using a qux here:
+  |
+3 |     qux sad()
+  |     ^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0999`.
+```
+
+The possible values of [`Applicability`][appl] are:
+
+- `MachineApplicable`: Can be applied mechanically.
+- `HasPlaceholders`: Cannot be applied mechanically because it has placeholder
+  text in the suggestions. For example: ```try adding a type: `let x:
+  <type>` ```.
+- `MaybeIncorrect`: Cannot be applied mechanically because the suggestion may
+  or may not be a good one.
+- `Unspecified`: Cannot be applied mechanically because we don't know which
+  of the above cases it falls into.
+
+[appl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/enum.Applicability.html
+
+### Suggestion Style Guide
+
+- Suggestions should not be a question. In particular, language like "did you
+  mean" should be avoided. Sometimes, it's unclear why a particular suggestion
+  is being made. In these cases, it's better to be upfront about what the
+  suggestion is.
+
+  Compare "did you mean: `Foo`" vs. "there is a struct with a similar name: `Foo`".
+
+- The message should not contain any phrases like "the following", "as shown",
+  etc. Use the span to convey what is being talked about.
+- The message may contain further instruction such as "to do xyz, use" or "to do
+  xyz, use abc".
+- The message may contain a name of a function, variable, or type, but avoid
+  whole expressions.
+
+## Lints
+
+The compiler linting infrastructure is defined in the [`rustc_middle::lint`][rlint]
+module.
+
+[rlint]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/lint/index.html
+
+### Declaring a lint
+
+The built-in compiler lints are defined in the [`rustc_lint`][builtin]
+crate. Lints that need to be implemented in other crates are defined in
+[`rustc_lint_defs`]. You should prefer to place lints in `rustc_lint` if
+possible. One benefit is that it is close to the dependency root, so it can be
+much faster to work on.
+
+[builtin]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/index.html
+[`rustc_lint_defs`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/index.html
+
+Every lint is implemented via a `struct` that implements the `LintPass` `trait`
+(you can also implement one of the more specific lint pass traits, either
+`EarlyLintPass` or `LateLintPass` depending on when is best for your lint to run).
+The trait implementation allows you to check certain syntactic constructs
+as the linter walks the AST. You can then choose to emit lints in a
+very similar way to compile errors.
+
+You also declare the metadata of a particular lint via the `declare_lint!`
+macro. This includes the name, the default level, a short description, and some
+more details.
+
+Note that the lint and the lint pass must be registered with the compiler.
+
+For example, the following lint checks for uses
+of `while true { ... }` and suggests using `loop { ... }` instead.
+
+```rust,ignore
+// Declare a lint called `WHILE_TRUE`
+declare_lint! {
+    WHILE_TRUE,
+
+    // warn-by-default
+    Warn,
+
+    // This string is the lint description
+    "suggest using `loop { }` instead of `while true { }`"
+}
+
+// This declares a struct and a lint pass, providing a list of associated lints. The
+// compiler currently doesn't use the associated lints directly (e.g., to not
+// run the pass or otherwise check that the pass emits the appropriate set of
+// lints). However, it's good to be accurate here as it's possible that we're
+// going to register the lints via the get_lints method on our lint pass (that
+// this macro generates).
+declare_lint_pass!(WhileTrue => [WHILE_TRUE]);
+
+// Helper function for `WhileTrue` lint.
+// Traverse through any amount of parenthesis and return the first non-parens expression.
+fn pierce_parens(mut expr: &ast::Expr) -> &ast::Expr {
+    while let ast::ExprKind::Paren(sub) = &expr.kind {
+        expr = sub;
+    }
+    expr
+}
+
+// `EarlyLintPass` has lots of methods. We only override the definition of
+// `check_expr` for this lint because that's all we need, but you could
+// override other methods for your own lint. See the rustc docs for a full
+// list of methods.
+impl EarlyLintPass for WhileTrue {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
+        if let ast::ExprKind::While(cond, ..) = &e.kind {
+            if let ast::ExprKind::Lit(ref lit) = pierce_parens(cond).kind {
+                if let ast::LitKind::Bool(true) = lit.kind {
+                    if !lit.span.from_expansion() {
+                        let condition_span = cx.sess.source_map().guess_head_span(e.span);
+                        cx.struct_span_lint(WHILE_TRUE, condition_span, |lint| {
+                            lint.build(fluent::example::use_loop)
+                                .span_suggestion_short(
+                                    condition_span,
+                                    fluent::example::suggestion,
+                                    "loop".to_owned(),
+                                    Applicability::MachineApplicable,
+                                )
+                                .emit();
+                        })
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+```fluent
+example-use-loop = denote infinite loops with `loop {"{"} ... {"}"}`
+  .suggestion = use `loop`
+```
+
+### Edition-gated lints
+
+Sometimes we want to change the behavior of a lint in a new edition. To do this,
+we just add the transition to our invocation of `declare_lint!`:
+
+```rust,ignore
+declare_lint! {
+    pub ANONYMOUS_PARAMETERS,
+    Allow,
+    "detects anonymous parameters",
+    Edition::Edition2018 => Warn,
+}
+```
+
+This makes the `ANONYMOUS_PARAMETERS` lint allow-by-default in the 2015 edition
+but warn-by-default in the 2018 edition.
+
+### Feature-gated lints
+
+Lints belonging to a feature should only be usable if the feature is enabled in the
+crate. To support this, lint declarations can contain a feature gate like so:
+
+```rust,ignore
+declare_lint! {
+    pub SOME_LINT_NAME,
+    Warn,
+    "a new and useful, but feature gated lint",
+    @feature_gate = sym::feature_name;
+}
+```
+
+### Future-incompatible lints
+
+The use of the term `future-incompatible` within the compiler has a slightly
+broader meaning than what rustc exposes to users of the compiler.
+
+Inside rustc, future-incompatible lints are for signalling to the user that code they have
+written may not compile in the future. In general, future-incompatible code
+exists for two reasons:
+* the user has written unsound code that the compiler mistakenly accepted. While
+it is within Rust's backwards compatibility guarantees to fix the soundness hole
+(breaking the user's code), the lint is there to warn the user that this will happen
+in some upcoming version of rustc *regardless of which edition the code uses*. This is the
+meaning that rustc exclusively exposes to users as "future incompatible".
+* the user has written code that will either no longer compiler *or* will change
+meaning in an upcoming *edition*. These are often called "edition lints" and can be
+typically seen in the various "edition compatibility" lint groups (e.g., `rust_2021_compatibility`)
+that are used to lint against code that will break if the user updates the crate's edition.
+
+A future-incompatible lint should be declared with the `@future_incompatible`
+additional "field":
+
+```rust,ignore
+declare_lint! {
+    pub ANONYMOUS_PARAMETERS,
+    Allow,
+    "detects anonymous parameters",
+    @future_incompatible = FutureIncompatibleInfo {
+        reference: "issue #41686 <https://github.com/rust-lang/rust/issues/41686>",
+        reason: FutureIncompatibilityReason::EditionError(Edition::Edition2018),
+    };
+}
+```
+
+Notice the `reason` field which describes why the future incompatible change is happening.
+This will change the diagnostic message the user receives as well as determine which
+lint groups the lint is added to. In the example above, the lint is an "edition lint"
+(since it's "reason" is `EditionError`) signifying to the user that the use of anonymous
+parameters will no longer compile in Rust 2018 and beyond.
+
+Inside [LintStore::register_lints][fi-lint-groupings], lints with `future_incompatible`
+fields get placed into either edition-based lint groups (if their `reason` is tied to
+an edition) or into the `future_incompatibility` lint group.
+
+[fi-lint-groupings]: https://github.com/rust-lang/rust/blob/51fd129ac12d5bfeca7d216c47b0e337bf13e0c2/compiler/rustc_lint/src/context.rs#L212-L237
+
+If you need a combination of options that's not supported by the
+`declare_lint!` macro, you can always change the `declare_lint!` macro
+to support this.
+
+### Renaming or removing a lint
+
+If it is determined that a lint is either improperly named or no longer needed,
+the lint must be registered for renaming or removal, which will trigger a warning if a user tries
+to use the old lint name. To declare a rename/remove, add a line with
+[`store.register_renamed`] or [`store.register_removed`] to the code of the
+[`rustc_lint::register_builtins`] function.
+
+```rust,ignore
+store.register_renamed("single_use_lifetime", "single_use_lifetimes");
+```
+
+[`store.register_renamed`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_renamed
+[`store.register_removed`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_removed
+[`rustc_lint::register_builtins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_builtins.html
+
+### Lint Groups
+
+Lints can be turned on in groups. These groups are declared in the
+[`register_builtins`][rbuiltins] function in [`rustc_lint::lib`][builtin]. The
+`add_lint_group!` macro is used to declare a new group.
+
+[rbuiltins]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_builtins.html
+
+For example,
+
+```rust,ignore
+add_lint_group!(sess,
+    "nonstandard_style",
+    NON_CAMEL_CASE_TYPES,
+    NON_SNAKE_CASE,
+    NON_UPPER_CASE_GLOBALS);
+```
+
+This defines the `nonstandard_style` group which turns on the listed lints. A
+user can turn on these lints with a `!#[warn(nonstandard_style)]` attribute in
+the source code, or by passing `-W nonstandard-style` on the command line.
+
+Some lint groups are created automatically in `LintStore::register_lints`. For instance,
+any lint declared with `FutureIncompatibleInfo` where the reason is
+`FutureIncompatibilityReason::FutureReleaseError` (the default when
+`@future_incompatible` is used in `declare_lint!`), will be added to
+the `future_incompatible` lint group. Editions also have their own lint groups
+(e.g., `rust_2021_compatibility`) automatically generated for any lints signaling
+future-incompatible code that will break in the specified edition.
+
+### Linting early in the compiler
+
+On occasion, you may need to define a lint that runs before the linting system
+has been initialized (e.g. during parsing or macro expansion). This is
+problematic because we need to have computed lint levels to know whether we
+should emit a warning or an error or nothing at all.
+
+To solve this problem, we buffer the lints until the linting system is
+processed. [`Session`][sessbl] and [`ParseSess`][parsebl] both have
+`buffer_lint` methods that allow you to buffer a lint for later. The linting
+system automatically takes care of handling buffered lints later.
+
+[sessbl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html#method.buffer_lint
+[parsebl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/parse/struct.ParseSess.html#method.buffer_lint
+
+Thus, to define a lint that runs early in the compilation, one defines a lint
+like normal but invokes the lint with `buffer_lint`.
+
+#### Linting even earlier in the compiler
+
+The parser (`rustc_ast`) is interesting in that it cannot have dependencies on
+any of the other `rustc*` crates. In particular, it cannot depend on
+`rustc_middle::lint` or `rustc_lint`, where all of the compiler linting
+infrastructure is defined. That's troublesome!
+
+To solve this, `rustc_ast` defines its own buffered lint type, which
+`ParseSess::buffer_lint` uses. After macro expansion, these buffered lints are
+then dumped into the `Session::buffered_lints` used by the rest of the compiler.
+
+## JSON diagnostic output
+
+The compiler accepts an `--error-format json` flag to output
+diagnostics as JSON objects (for the benefit of tools such as `cargo
+fix` or the RLS). It looks like this:
+
+```console
+$ rustc json_error_demo.rs --error-format json
+{"message":"cannot add `&str` to `{integer}`","code":{"code":"E0277","explanation":"\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n    fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n    foo.bar();\n}\n\nfn main() {\n    // we now call the method with the i32 type, which doesn't implement\n    // the Foo trait\n    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n    fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n    foo.bar(); // we can now use this method since i32 implements the\n               // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n    fn bar(&self) {}\n}\n\nfn main() {\n    some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n    println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n                           //        implemented for the type `T`\n}\n\nfn main() {\n    // We now call the method with the i32 type,\n    // which *does* implement the Debug trait.\n    some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n    println!(\"{:?}\", foo);\n}\n\nfn main() {\n    // Calling the method is still fine, as i32 implements Debug.\n    some_func(5i32);\n\n    // This would fail to compile now:\n    // struct WithoutDebug;\n    // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"},"level":"error","spans":[{"file_name":"json_error_demo.rs","byte_start":50,"byte_end":51,"line_start":4,"line_end":4,"column_start":7,"column_end":8,"is_primary":true,"text":[{"text":"    a + b","highlight_start":7,"highlight_end":8}],"label":"no implementation for `{integer} + &str`","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"the trait `std::ops::Add<&str>` is not implemented for `{integer}`","code":null,"level":"help","spans":[],"children":[],"rendered":null}],"rendered":"error[E0277]: cannot add `&str` to `{integer}`\n --> json_error_demo.rs:4:7\n  |\n4 |     a + b\n  |       ^ no implementation for `{integer} + &str`\n  |\n  = help: the trait `std::ops::Add<&str>` is not implemented for `{integer}`\n\n"}
+{"message":"aborting due to previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to previous error\n\n"}
+{"message":"For more information about this error, try `rustc --explain E0277`.","code":null,"level":"","spans":[],"children":[],"rendered":"For more information about this error, try `rustc --explain E0277`.\n"}
+```
+
+Note that the output is a series of lines, each of which is a JSON
+object, but the series of lines taken together is, unfortunately, not
+valid JSON, thwarting tools and tricks (such as [piping to `python3 -m
+json.tool`](https://docs.python.org/3/library/json.html#module-json.tool))
+that require such. (One speculates that this was intentional for LSP
+performance purposes, so that each line/object can be sent to RLS as
+it is flushed?)
+
+Also note the "rendered" field, which contains the "human" output as a
+string; this was introduced so that UI tests could both make use of
+the structured JSON and see the "human" output (well, _sans_ colors)
+without having to compile everything twice.
+
+The "human" readable and the json format emitter can be found under
+`rustc_errors`, both were moved from the `rustc_ast` crate to the
+[rustc_errors crate](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/index.html).
+
+The JSON emitter defines [its own `Diagnostic`
+struct](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/json/struct.Diagnostic.html)
+(and sub-structs) for the JSON serialization. Don't confuse this with
+[`errors::Diagnostic`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Diagnostic.html)!
+
+## `#[rustc_on_unimplemented(...)]`
+
+The `#[rustc_on_unimplemented]` attribute allows trait definitions to add specialized
+notes to error messages when an implementation was expected but not found.
+You can refer to the trait's generic arguments by name and to the resolved type using `Self`.
+
+For example:
+
+```rust,ignore
+#![feature(rustc_attrs)]
+
+#[rustc_on_unimplemented="an iterator over elements of type `{A}` \
+    cannot be built from a collection of type `{Self}`"]
+trait MyIterator<A> {
+    fn next(&mut self) -> A;
+}
+
+fn iterate_chars<I: MyIterator<char>>(i: I) {
+    // ...
+}
+
+fn main() {
+    iterate_chars(&[1, 2, 3][..]);
+}
+```
+
+When the user compiles this, they will see the following;
+
+```txt
+error[E0277]: the trait bound `&[{integer}]: MyIterator<char>` is not satisfied
+  --> <anon>:14:5
+   |
+14 |     iterate_chars(&[1, 2, 3][..]);
+   |     ^^^^^^^^^^^^^ an iterator over elements of type `char` cannot be built from a collection of type `&[{integer}]`
+   |
+   = help: the trait `MyIterator<char>` is not implemented for `&[{integer}]`
+   = note: required by `iterate_chars`
+```
+
+`rustc_on_unimplemented` also supports advanced filtering for better targeting
+of messages, as well as modifying specific parts of the error message. You
+target the text of:
+
+ - the main error message (`message`)
+ - the label (`label`)
+ - an extra note (`note`)
+
+For example, the following attribute
+
+```rust,ignore
+#[rustc_on_unimplemented(
+    message="message",
+    label="label",
+    note="note"
+)]
+trait MyIterator<A> {
+    fn next(&mut self) -> A;
+}
+```
+
+Would generate the following output:
+
+```text
+error[E0277]: message
+  --> <anon>:14:5
+   |
+14 |     iterate_chars(&[1, 2, 3][..]);
+   |     ^^^^^^^^^^^^^ label
+   |
+   = note: note
+   = help: the trait `MyIterator<char>` is not implemented for `&[{integer}]`
+   = note: required by `iterate_chars`
+```
+
+To allow more targeted error messages, it is possible to filter the
+application of these fields based on a variety of attributes when using
+`on`:
+
+ - `crate_local`: whether the code causing the trait bound to not be
+   fulfilled is part of the user's crate. This is used to avoid suggesting
+   code changes that would require modifying a dependency.
+ - Any of the generic arguments that can be substituted in the text can be
+   referred by name as well for filtering, like `Rhs="i32"`, except for
+   `Self`.
+ - `_Self`: to filter only on a particular calculated trait resolution, like
+   `Self="std::iter::Iterator<char>"`. This is needed because `Self` is a
+   keyword which cannot appear in attributes.
+ - `direct`: user-specified rather than derived obligation.
+ - `from_method`: usable both as boolean (whether the flag is present, like
+   `crate_local`) or matching against a particular method. Currently used
+   for `try`.
+ - `from_desugaring`: usable both as boolean (whether the flag is present)
+   or matching against a particular desugaring. The desugaring is identified
+   with its variant name in the `DesugaringKind` enum.
+
+For example, the `Iterator` trait can be annotated in the following way:
+
+```rust,ignore
+#[rustc_on_unimplemented(
+    on(
+        _Self="&str",
+        note="call `.chars()` or `.as_bytes()` on `{Self}`"
+    ),
+    message="`{Self}` is not an iterator",
+    label="`{Self}` is not an iterator",
+    note="maybe try calling `.iter()` or a similar method"
+)]
+pub trait Iterator {}
+```
+
+Which would produce the following outputs:
+
+```text
+error[E0277]: `Foo` is not an iterator
+ --> src/main.rs:4:16
+  |
+4 |     for foo in Foo {}
+  |                ^^^ `Foo` is not an iterator
+  |
+  = note: maybe try calling `.iter()` or a similar method
+  = help: the trait `std::iter::Iterator` is not implemented for `Foo`
+  = note: required by `std::iter::IntoIterator::into_iter`
+
+error[E0277]: `&str` is not an iterator
+ --> src/main.rs:5:16
+  |
+5 |     for foo in "" {}
+  |                ^^ `&str` is not an iterator
+  |
+  = note: call `.chars()` or `.bytes() on `&str`
+  = help: the trait `std::iter::Iterator` is not implemented for `&str`
+  = note: required by `std::iter::IntoIterator::into_iter`
+```
+
+If you need to filter on multiple attributes, you can use `all`, `any` or
+`not` in the following way:
+
+```rust,ignore
+#[rustc_on_unimplemented(
+    on(
+        all(_Self="&str", T="std::string::String"),
+        note="you can coerce a `{T}` into a `{Self}` by writing `&*variable`"
+    )
+)]
+pub trait From<T>: Sized { /* ... */ }
+```
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-codes.md b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-codes.md
new file mode 100644
index 000000000..3618b43cd
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-codes.md
@@ -0,0 +1,79 @@
+# Diagnostic codes
+We generally try to assign each error message a unique code like `E0123`. These
+codes are defined in the compiler in the `diagnostics.rs` files found in each
+crate, which basically consist of macros. The codes come in two varieties: those
+that have an extended write-up, and those that do not. Whenever possible, if you
+are making a new code, you should write an extended write-up.
+
+### Allocating a fresh code
+
+Error codes are stored in `compiler/rustc_error_codes`.
+
+To create a new error, you first need to find the next available
+code. You can find it with `tidy`:
+
+```
+./x.py test tidy
+```
+
+This will invoke the tidy script, which generally checks that your code obeys
+our coding conventions. One of those jobs is to check that diagnostic codes are
+indeed unique. Once it is finished with that, tidy will print out the lowest
+unused code:
+
+```
+...
+tidy check (x86_64-apple-darwin)
+* 470 error codes
+* highest error code: E0591
+...
+```
+
+Here we see the highest error code in use is `E0591`, so we _probably_ want
+`E0592`. To be sure, run `rg E0592` and check, you should see no references.
+
+Ideally, you will write an extended description for your error,
+which will go in `rustc_error_codes/src/error_codes/E0592.md`.
+To register the error, open `rustc_error_codes/src/error_codes.rs` and add the
+code (in its proper numerical order) into` register_diagnostics!` macro, like
+this:
+
+```rust
+register_diagnostics! {
+    ...
+    E0592: include_str!("./error_codes/E0592.md"),
+}
+```
+
+But you can also add it without an extended description:
+
+```rust
+register_diagnostics! {
+    ...
+    E0592, // put a description here
+}
+```
+
+To actually issue the error, you can use the `struct_span_err!` macro:
+
+```rust
+struct_span_err!(self.tcx.sess, // some path to the session here
+                 span, // whatever span in the source you want
+                 E0592, // your new error code
+                 fluent::example::an_error_message)
+    .emit() // actually issue the error
+```
+
+If you want to add notes or other snippets, you can invoke methods before you
+call `.emit()`:
+
+```rust
+struct_span_err!(...)
+    .span_label(another_span, fluent::example::example_label)
+    .span_note(another_span, fluent::example::separate_note)
+    .emit_()
+```
+
+For an example of a PR adding an error code, see [#76143].
+
+[#76143]: https://github.com/rust-lang/rust/pull/76143
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
new file mode 100644
index 000000000..b6b6e0fa9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
@@ -0,0 +1,147 @@
+# Diagnostic Items
+While writing lints it's common to check for specific types, traits and
+functions. This raises the question on how to check for these. Types can be
+checked by their complete type path. However, this requires hard coding paths
+and can lead to misclassifications in some edge cases. To counteract this,
+rustc has introduced diagnostic items that are used to identify types via
+[`Symbol`]s.
+
+## Finding diagnostic items
+Diagnostic items are added to items inside `rustc`/`std`/`core` with the
+`rustc_diagnostic_item` attribute. The item for a specific type can be found by
+opening the source code in the documentation and looking for this attribute.
+Note that it's often added with the `cfg_attr` attribute to avoid compilation
+errors during tests. A definition often looks like this:
+
+```rs
+// This is the diagnostic item for this type   vvvvvvv
+#[cfg_attr(not(test), rustc_diagnostic_item = "Penguin")]
+struct Penguin;
+```
+
+Diagnostic items are usually only added to traits, types and standalone
+functions. If the goal is to check for an associated type or method, please use
+the diagnostic item of the item and reference [*How To Use Diagnostic
+Items*](#how-to-use-diagnostic-items).
+
+## Adding diagnostic items
+A new diagnostic item can be added with these two steps:
+
+1. Find the target item inside the Rust repo. Now add the diagnostic item as a
+   string via the `rustc_diagnostic_item` attribute. This can sometimes cause
+   compilation errors while running tests. These errors can be avoided by using
+   the `cfg_attr` attribute with the `not(test)` condition (it's fine adding
+   then for all `rustc_diagnostic_item` attributes as a preventive manner). At
+   the end, it should look like this:
+
+    ```rs
+    // This will be the new diagnostic item        vvv
+    #[cfg_attr(not(test), rustc_diagnostic_item = "Cat")]
+    struct Cat;
+    ```
+
+    For the naming conventions of diagnostic items, please refer to
+    [*Naming Conventions*](#naming-conventions).
+
+2. As of <!-- date: 2022-02 --> February 2022, diagnostic items in code are
+   accessed via symbols in [`rustc_span::symbol::sym`]. To add your newly
+   created diagnostic item simply open the module file and add the name (In
+   this case `Cat`) at the correct point in the list.
+
+Now you can create a pull request with your changes. :tada: (Note that when
+using diagnostic items in other projects like Clippy, it might take some time
+until the repos get synchronized.)
+
+## Naming conventions
+Diagnostic items don't have a set in stone naming convention yet. These are
+some guidelines that should be used for the future, but might differ from
+existing names:
+
+* Types, traits and enums are named using UpperCamelCase (Examples: `Iterator`,
+* `HashMap`, ...)
+* For type names that are used multiple times like `Writer` it's good to choose
+  a more precise name, maybe by adding the module to it. (Example: `IoWriter`)
+* Associated items should not get their own diagnostic items, but instead be
+  accessed indirectly by the diagnostic item of the type they're originating
+  from.
+* Freestanding functions like `std::mem::swap()` should be named using
+  `snake_case` with one important (export) module as a prefix (Example:
+  `mem_swap`, `cmp_max`)
+* Modules should usually not have a diagnostic item attached to them.
+  Diagnostic items were added to avoid the usage of paths, using them on
+  modules would therefore most likely to be counterproductive.
+
+## Using diagnostic items
+In rustc, diagnostic items are looked up via [`Symbol`]s from inside the
+[`rustc_span::symbol::sym`] module. These can then be mapped to [`DefId`]s
+using [`TyCtxt::get_diagnostic_item()`] or checked if they match a [`DefId`]
+using [`TyCtxt::is_diagnostic_item()`]. When mapping from a diagnostic item to
+a [`DefId`], the method will return a `Option<DefId>`. This can be `None` if
+either the symbol isn't a diagnostic item or the type is not registered, for
+instance when compiling with `#[no_std]`. All following examples are based on
+[`DefId`]s and their usage.
+
+### Example: Checking for a type
+```rust
+use rustc_span::symbol::sym;
+
+/// This example checks if the given type (`ty`) has the type `HashMap` using
+/// `TyCtxt::is_diagnostic_item()`
+fn example_1(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::HashMap, adt.did),
+        _ => false,
+    }
+}
+```
+
+### Example: Checking for a trait implementation
+```rust
+/// This example checks if a given [`DefId`] from a method is part of a trait
+/// implementation defined by a diagnostic item.
+fn is_diag_trait_item(
+    cx: &LateContext<'_>,
+    def_id: DefId,
+    diag_item: Symbol
+) -> bool {
+    if let Some(trait_did) = cx.tcx.trait_of_item(def_id) {
+        return cx.tcx.is_diagnostic_item(diag_item, trait_did);
+    }
+    false
+}
+```
+
+### Associated Types
+Associated types of diagnostic items can be accessed indirectly by first
+getting the [`DefId`] of the trait and then calling
+[`TyCtxt::associated_items()`]. This returns an [`AssocItems`] object which can
+be used for further checks. Checkout
+[`clippy_utils::ty::get_iterator_item_ty()`] for an example usage of this.
+
+### Usage in Clippy
+Clippy tries to use diagnostic items where possible and has developed some
+wrapper and utility functions. Please also refer to its documentation when
+using diagnostic items in Clippy. (See [*Common tools for writing
+lints*][clippy-Common-tools-for-writing-lints].)
+
+## Related issues
+This lists some related issues. These are probably only interesting to people
+who really want to take a deep dive into the topic :)
+
+* [rust#60966]: The Rust PR that introduced diagnostic items
+* [rust-clippy#5393]: Clippy's tracking issue for moving away from hard coded paths to
+  diagnostic item
+
+<!-- Links -->
+
+[`rustc_span::symbol::sym`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/sym/index.html
+[`Symbol`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Symbol.html
+[`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html
+[`TyCtxt::get_diagnostic_item()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.get_diagnostic_item
+[`TyCtxt::is_diagnostic_item()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.is_diagnostic_item
+[`TyCtxt::associated_items()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.associated_items
+[`AssocItems`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/assoc/struct.AssocItems.html
+[`clippy_utils::ty::get_iterator_item_ty()`]: https://github.com/rust-lang/rust-clippy/blob/305177342fbc622c0b3cb148467bab4b9524c934/clippy_utils/src/ty.rs#L55-L72
+[clippy-Common-tools-for-writing-lints]: https://doc.rust-lang.org/nightly/clippy/development/common_tools_writing_lints.html
+[rust#60966]: https://github.com/rust-lang/rust/pull/60966
+[rust-clippy#5393]: https://github.com/rust-lang/rust-clippy/issues/5393
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-structs.md b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-structs.md
new file mode 100644
index 000000000..f28350e03
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-structs.md
@@ -0,0 +1,375 @@
+# Diagnostic and subdiagnostic structs
+rustc has two diagnostic derives that can be used to create simple diagnostics,
+which are recommended to be used when they are applicable:
+`#[derive(SessionDiagnostic)]` and `#[derive(SessionSubdiagnostic)]`.
+
+Diagnostics created with the derive macros can be translated into different
+languages and each has a slug that uniquely identifies the diagnostic.
+
+## `#[derive(SessionDiagnostic)]`
+Instead of using the `DiagnosticBuilder` API to create and emit diagnostics,
+the `SessionDiagnostic` derive can be used. `#[derive(SessionDiagnostic)]` is
+only applicable for simple diagnostics that don't require much logic in
+deciding whether or not to add additional subdiagnostics.
+
+Consider the [definition][defn] of the "field already declared" diagnostic
+shown below:
+
+```rust,ignore
+#[derive(SessionDiagnostic)]
+#[error(typeck::field_already_declared, code = "E0124")]
+pub struct FieldAlreadyDeclared {
+    pub field_name: Ident,
+    #[primary_span]
+    #[label]
+    pub span: Span,
+    #[label = "previous-decl-label"]
+    pub prev_span: Span,
+}
+```
+
+`SessionDiagnostic` can only be applied to structs. Every `SessionDiagnostic`
+has to have one attribute applied to the struct itself: either `#[error(..)]`
+for defining errors, or `#[warning(..)]` for defining warnings.
+
+If an error has an error code (e.g. "E0624"), then that can be specified using
+the `code` sub-attribute. Specifying a `code` isn't mandatory, but if you are
+porting a diagnostic that uses `DiagnosticBuilder` to use `SessionDiagnostic`
+then you should keep the code if there was one.
+
+Both `#[error(..)]` and `#[warning(..)]` must provide a slug as the first
+positional argument (a path to an item in `rustc_errors::fluent::*`). A slug
+uniquely identifies the diagnostic and is also how the compiler knows what
+error message to emit (in the default locale of the compiler, or in the locale
+requested by the user). See [translation documentation](./translation.md) to
+learn more about how translatable error messages are written and how slug
+items are generated.
+
+In our example, the Fluent message for the "field already declared" diagnostic
+looks like this:
+
+```fluent
+typeck-field-already-declared =
+    field `{$field_name}` is already declared
+    .label = field already declared
+    .previous-decl-label = `{$field_name}` first declared here
+```
+
+`typeck-field-already-declared` is the slug from our example and is followed
+by the diagnostic message.
+
+Every field of the `SessionDiagnostic` which does not have an annotation is
+available in Fluent messages as a variable, like `field_name` in the example
+above. Fields can be annotated `#[skip_arg]` if this is undesired.
+
+Using the `#[primary_span]` attribute on a field (that has type `Span`)
+indicates the primary span of the diagnostic which will have the main message
+of the diagnostic.
+
+Diagnostics are more than just their primary message, they often include
+labels, notes, help messages and suggestions, all of which can also be
+specified on a `SessionDiagnostic`.
+
+`#[label]`, `#[help]` and `#[note]` can all be applied to fields which have the
+type `Span`. Applying any of these attributes will create the corresponding
+subdiagnostic with that `Span`. These attributes will look for their
+diagnostic message in a Fluent attribute attached to the primary Fluent
+message. In our example, `#[label]` will look for
+`typeck-field-already-declared.label` (which has the message "field already
+declared"). If there is more than one subdiagnostic of the same type, then
+these attributes can also take a value that is the attribute name to look for
+(e.g. `previous-decl-label` in our example).
+
+Other types have special behavior when used in a `SessionDiagnostic` derive:
+
+- Any attribute applied to an `Option<T>` and will only emit a
+  subdiagnostic if the option is `Some(..)`.
+- Any attribute applied to a `Vec<T>` will be repeated for each element of the
+  vector.
+
+`#[help]` and `#[note]` can also be applied to the struct itself, in which case
+they work exactly like when applied to fields except the subdiagnostic won't
+have a `Span`. These attributes can also be applied to fields of type `()` for
+the same effect, which when combined with the `Option` type can be used to
+represent optional `#[note]`/`#[help]` subdiagnostics.
+
+Suggestions can be emitted using one of four field attributes:
+
+- `#[suggestion(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_hidden(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_short(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_verbose(message = "...", code = "...", applicability = "...")]`
+
+Suggestions must be applied on either a `Span` field or a `(Span,
+MachineApplicability)` field. Similarly to other field attributes, `message`
+specifies the Fluent attribute with the message and defaults to `.suggestion`.
+`code` specifies the code that should be suggested as a replacement and is a
+format string (e.g. `{field_name}` would be replaced by the value of the
+`field_name` field of the struct), not a Fluent identifier. `applicability` can
+be used to specify the applicability in the attribute, it cannot be used when
+the field's type contains an `Applicability`.
+
+In the end, the `SessionDiagnostic` derive will generate an implementation of
+`SessionDiagnostic` that looks like the following:
+
+```rust,ignore
+impl SessionDiagnostic for FieldAlreadyDeclared {
+    fn into_diagnostic(self, sess: &'_ rustc_session::Session) -> DiagnosticBuilder<'_> {
+        let mut diag = sess.struct_err_with_code(
+            rustc_errors::DiagnosticMessage::fluent("typeck-field-already-declared"),
+            rustc_errors::DiagnosticId::Error("E0124")
+        );
+        diag.set_span(self.span);
+        diag.span_label(
+            self.span,
+            rustc_errors::DiagnosticMessage::fluent_attr("typeck-field-already-declared", "label")
+        );
+        diag.span_label(
+            self.prev_span,
+            rustc_errors::DiagnosticMessage::fluent_attr("typeck-field-already-declared", "previous-decl-label")
+        );
+        diag
+    }
+}
+```
+
+Now that we've defined our diagnostic, how do we [use it][use]? It's quite
+straightforward, just create an instance of the struct and pass it to
+`emit_err` (or `emit_warning`):
+
+```rust,ignore
+tcx.sess.emit_err(FieldAlreadyDeclared {
+    field_name: f.ident,
+    span: f.span,
+    prev_span,
+});
+```
+
+### Reference
+`#[derive(SessionDiagnostic)]` supports the following attributes:
+
+- `#[error(slug, code = "...")]` or `#[warning(slug, code = "...")]`
+  - _Applied to struct._
+  - _Mandatory_
+  - Defines the struct to be representing an error or a warning.
+  - Slug (_Mandatory_)
+    - Uniquely identifies the diagnostic and corresponds to its Fluent message,
+      mandatory.
+    - A path to an item in `rustc_errors::fluent`. Always in a module starting
+      with a Fluent resource name (which is typically the name of the crate
+      that the diagnostic is from), e.g.
+      `rustc_errors::fluent::typeck::field_already_declared`
+      (`rustc_errors::fluent` is implicit in the attribute, so just
+      `typeck::field_already_declared`).
+    - See [translation documentation](./translation.md).
+  - `code = "..."` (_Optional_)
+    - Specifies the error code.
+- `#[note]` or `#[note = "..."]` (_Optional_)
+  - _Applied to struct or `Span`/`()` fields._
+  - Adds a note subdiagnostic.
+  - Value is the Fluent attribute (relative to the Fluent message specified by
+    `slug`) for the note's message
+    - Defaults to `note`.
+  - If applied to a `Span` field, creates a spanned note.
+- `#[help]` or `#[help = "..."]` (_Optional_)
+  - _Applied to struct or `Span`/`()` fields._
+  - Adds a help subdiagnostic.
+  - Value is the Fluent attribute (relative to the Fluent message specified by
+    `slug`) for the help's message.
+    - Defaults to `help`.
+  - If applied to a `Span` field, creates a spanned help.
+- `#[label]` or `#[label = "..."]` (_Optional_)
+  - _Applied to `Span` fields._
+  - Adds a label subdiagnostic.
+  - Value is the Fluent attribute (relative to the Fluent message specified by
+    `slug`) for the label's message.
+    - Defaults to `label`.
+- `#[suggestion{,_hidden,_short,_verbose}(message = "...", code = "...", applicability = "...")]`
+  (_Optional_)
+  - _Applied to `(Span, MachineApplicability)` or `Span` fields._
+  - Adds a suggestion subdiagnostic.
+  - `message = "..."` (_Mandatory_)
+    - Value is the Fluent attribute (relative to the Fluent message specified
+      by `slug`) for the suggestion's message.
+    - Defaults to `suggestion`.
+  - `code = "..."` (_Mandatory_)
+    - Value is a format string indicating the code to be suggested as a
+      replacement.
+  - `applicability = "..."` (_Optional_)
+    - String which must be one of `machine-applicable`, `maybe-incorrect`,
+      `has-placeholders` or `unspecified`.
+- `#[subdiagnostic]`
+  - _Applied to a type that implements `AddToDiagnostic` (from
+    `#[derive(SessionSubdiagnostic)]`)._
+  - Adds the subdiagnostic represented by the subdiagnostic struct.
+- `#[primary_span]` (_Optional_)
+  - _Applied to `Span` fields._
+  - Indicates the primary span of the diagnostic.
+- `#[skip_arg]` (_Optional_)
+  - _Applied to any field._
+  - Prevents the field from being provided as a diagnostic argument.
+
+## `#[derive(SessionSubdiagnostic)]`
+It is common in the compiler to write a function that conditionally adds a
+specific subdiagnostic to an error if it is applicable. Oftentimes these
+subdiagnostics could be represented using a diagnostic struct even if the
+overall diagnostic could not. In this circumstance, the `SessionSubdiagnostic`
+derive can be used to represent a partial diagnostic (e.g a note, label, help or
+suggestion) as a struct.
+
+Consider the [definition][subdiag_defn] of the "expected return type" label
+shown below:
+
+```rust
+#[derive(SessionSubdiagnostic)]
+pub enum ExpectedReturnTypeLabel<'tcx> {
+    #[label(typeck::expected_default_return_type)]
+    Unit {
+        #[primary_span]
+        span: Span,
+    },
+    #[label(typeck::expected_return_type)]
+    Other {
+        #[primary_span]
+        span: Span,
+        expected: Ty<'tcx>,
+    },
+}
+```
+
+Unlike `SessionDiagnostic`, `SessionSubdiagnostic` can be applied to structs or
+enums. Attributes that are placed on the type for structs are placed on each
+variants for enums (or vice versa). Each `SessionSubdiagnostic` should have one
+attribute applied to the struct or each variant, one of:
+
+- `#[label(..)]` for defining a label
+- `#[note(..)]` for defining a note
+- `#[help(..)]` for defining a help
+- `#[suggestion{,_hidden,_short,_verbose}(..)]` for defining a suggestion
+
+All of the above must provide a slug as the first positional argument (a path
+to an item in `rustc_errors::fluent::*`). A slug uniquely identifies the
+diagnostic and is also how the compiler knows what error message to emit (in
+the default locale of the compiler, or in the locale requested by the user).
+See [translation documentation](./translation.md) to learn more about how
+translatable error messages are written and how slug items are generated.
+
+In our example, the Fluent message for the "expected return type" label
+looks like this:
+
+```fluent
+typeck-expected-default-return-type = expected `()` because of default return type
+
+typeck-expected-return-type = expected `{$expected}` because of return type
+```
+
+Using the `#[primary_span]` attribute on a field (with type `Span`) will denote
+the primary span of the subdiagnostic. A primary span is only necessary for a
+label or suggestion, which can not be spanless.
+
+Every field of the type/variant which does not have an annotation is available
+in Fluent messages as a variable. Fields can be annotated `#[skip_arg]` if this
+is undesired.
+
+Like `SessionDiagnostic`, `SessionSubdiagnostic` supports `Option<T>` and
+`Vec<T>` fields.
+
+Suggestions can be emitted using one of four attributes on the type/variant:
+
+- `#[suggestion(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_hidden(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_short(message = "...", code = "...", applicability = "...")]`
+- `#[suggestion_verbose(message = "...", code = "...", applicability = "...")]`
+
+Suggestions require `#[primary_span]` be set on a field and can have the
+following sub-attributes:
+
+- `message` specifies the Fluent attribute with the message and defaults to
+  `.suggestion`.
+- `code` specifies the code that should be suggested as a replacement and is a
+  format string (e.g. `{field_name}` would be replaced by the value of the
+  `field_name` field of the struct), not a Fluent identifier.
+- `applicability` can be used to specify the applicability in the attribute, it
+  cannot be used when the field's type contains an `Applicability`.
+
+Applicabilities can also be specified as a field (of type `Applicability`)
+using the `#[applicability]` attribute.
+
+In the end, the `SessionSubdiagnostic` derive will generate an implementation
+of `SessionSubdiagnostic` that looks like the following:
+
+```rust
+impl<'tcx> AddToDiagnostic for ExpectedReturnTypeLabel<'tcx> {
+    fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) {
+        use rustc_errors::{Applicability, IntoDiagnosticArg};
+        match self {
+            ExpectedReturnTypeLabel::Unit { span } => {
+                diag.span_label(span, DiagnosticMessage::fluent("typeck-expected-default-return-type"))
+            }
+            ExpectedReturnTypeLabel::Other { span, expected } => {
+                diag.set_arg("expected", expected);
+                diag.span_label(span, DiagnosticMessage::fluent("typeck-expected-return-type"))
+            }
+
+        }
+    }
+}
+```
+
+Once defined, a subdiagnostic can be used by passing it to the `subdiagnostic`
+function ([example][subdiag_use_1] and [example][subdiag_use_2]) on a
+diagnostic or by assigning it to a `#[subdiagnostic]`-annotated field of a
+diagnostic struct.
+
+### Reference
+`#[derive(SessionSubdiagnostic)]` supports the following attributes:
+
+- `#[label(slug)]`, `#[help(slug)]` or `#[note(slug)]`
+  - _Applied to struct or enum variant. Mutually exclusive with struct/enum variant attributes._
+  - _Mandatory_
+  - Defines the type to be representing a label, help or note.
+  - Slug (_Mandatory_)
+    - Uniquely identifies the diagnostic and corresponds to its Fluent message,
+      mandatory.
+    - A path to an item in `rustc_errors::fluent`. Always in a module starting
+      with a Fluent resource name (which is typically the name of the crate
+      that the diagnostic is from), e.g.
+      `rustc_errors::fluent::typeck::field_already_declared`
+      (`rustc_errors::fluent` is implicit in the attribute, so just
+      `typeck::field_already_declared`).
+    - See [translation documentation](./translation.md).
+- `#[suggestion{,_hidden,_short,_verbose}(message = "...", code = "...", applicability = "...")]`
+  - _Applied to struct or enum variant. Mutually exclusive with struct/enum variant attributes._
+  - _Mandatory_
+  - Defines the type to be representing a suggestion.
+  - `message = "..."` (_Mandatory_)
+    - Value is the Fluent attribute (relative to the Fluent message specified
+      by `slug`) for the suggestion's message.
+    - Defaults to `suggestion`.
+  - `code = "..."` (_Mandatory_)
+    - Value is a format string indicating the code to be suggested as a
+      replacement.
+  - `applicability = "..."` (_Optional_)
+    - _Mutually exclusive with `#[applicability]` on a field._
+    - Value is the applicability of the suggestion.
+    - String which must be one of:
+      - `machine-applicable`
+      - `maybe-incorrect`
+      - `has-placeholders`
+      - `unspecified`
+- `#[primary_span]` (_Mandatory_ for labels and suggestions; _optional_ otherwise)
+  - _Applied to `Span` fields._
+  - Indicates the primary span of the subdiagnostic.
+- `#[applicability]` (_Optional_; only applicable to suggestions)
+  - _Applied to `Applicability` fields._
+  - Indicates the applicability of the suggestion.
+- `#[skip_arg]` (_Optional_)
+  - _Applied to any field._
+  - Prevents the field from being provided as a diagnostic argument.
+
+[defn]: https://github.com/rust-lang/rust/blob/bbe9d27b8ff36da56638aa43d6d0cdfdf89a4e57/compiler/rustc_typeck/src/errors.rs#L65-L74
+[use]: https://github.com/rust-lang/rust/blob/eb82facb1626166188d49599a3313fc95201f556/compiler/rustc_typeck/src/collect.rs#L981-L985
+
+[subdiag_defn]: https://github.com/rust-lang/rust/blob/e70c60d34b9783a2fd3171d88d248c2e0ec8ecdd/compiler/rustc_typeck/src/errors.rs#L220-L233
+[subdiag_use_1]: https://github.com/rust-lang/rust/blob/e70c60d34b9783a2fd3171d88d248c2e0ec8ecdd/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs#L556-L560
+[subdiag_use_2]: https://github.com/rust-lang/rust/blob/e70c60d34b9783a2fd3171d88d248c2e0ec8ecdd/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs#L575-L579
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/error-guaranteed.md b/src/doc/rustc-dev-guide/src/diagnostics/error-guaranteed.md
new file mode 100644
index 000000000..d92ba62ab
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/error-guaranteed.md
@@ -0,0 +1,34 @@
+# `ErrorGuaranteed`
+The previous sections have been about the error message that a user of the
+compiler sees. But emitting an error can also have a second important side
+effect within the compiler source code: it generates an
+[`ErrorGuaranteed`][errorguar].
+
+`ErrorGuaranteed` is a zero-sized type that is unconstructable outside of the
+[`rustc_errors`][rerrors] crate. It is generated whenever an error is reported
+to the user, so that if your compiler code ever encounters a value of type
+`ErrorGuaranteed`, the compilation is _statically guaranteed to fail_. This is
+useful for avoiding unsoundness bugs because you can statically check that an
+error code path leads to a failure.
+
+There are some important considerations about the usage of `ErrorGuaranteed`:
+
+* It does _not_ convey information about the _kind_ of error. For example, the
+  error may be due (indirectly) to a `delay_span_bug` or other compiler error.
+  Thus, you should not rely on
+  `ErrorGuaranteed` when deciding whether to emit an error, or what kind of error
+  to emit.
+* `ErrorGuaranteed` should not be used to indicate that a compilation _will
+  emit_ an error in the future. It should be used to indicate that an error
+  _has already been_ emitted -- that is, the [`emit()`][emit] function has
+  already been called.  For example, if we detect that a future part of the
+  compiler will error, we _cannot_ use `ErrorGuaranteed` unless we first emit
+  an error ourselves.
+
+Thankfully, in most cases, it should be statically impossible to abuse
+`ErrorGuaranteed`.
+
+[errorguar]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.ErrorGuaranteed.html
+[rerrors]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/index.html
+[dsp]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Handler.html#method.delay_span_bug
+[emit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/diagnostic_builder/struct.DiagnosticBuilder.html#method.emit
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
new file mode 100644
index 000000000..39007f8d1
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -0,0 +1,123 @@
+# Lints
+This page documents some of the machinery around lint registration and how we
+run lints in the compiler.
+
+The [`LintStore`] is the central piece of infrastructure, around which
+everything rotates. It's not available during the early parts of compilation
+(i.e., before TyCtxt) in most code, as we need to fill it in with all of the
+lints, which can only happen after plugin registration.
+
+## Lints vs. lint passes
+There are two parts to the linting mechanism within the compiler: lints and
+lint passes. Unfortunately, a lot of the documentation we have refers to both
+of these as just "lints."
+
+First, we have the lint declarations themselves: this is where the name and
+default lint level and other metadata come from. These are normally defined by
+way of the [`declare_lint!`] macro, which boils down to a static with type
+`&rustc_session::lint::Lint`.
+
+As of <!-- date: 2022-02 --> February 2022, we lint against direct declarations
+without the use of the macro today (although this may change in the future, as
+the macro is somewhat unwieldy to add new fields to, like all macros).
+
+Lint declarations don't carry any "state" - they are merely global identifiers
+and descriptions of lints. We assert at runtime that they are not registered
+twice (by lint name).
+
+Lint passes are the meat of any lint. Notably, there is not a one-to-one
+relationship between lints and lint passes; a lint might not have any lint pass
+that emits it, it could have many, or just one -- the compiler doesn't track
+whether a pass is in any way associated with a particular lint, and frequently
+lints are emitted as part of other work (e.g., type checking, etc.).
+
+## Registration
+
+### High-level overview
+In [`rustc_interface::register_plugins`] the [`LintStore`] is created and all
+lints are registered.
+
+There are four 'sources' of lints:
+
+* internal lints: lints only used by the rustc codebase
+* builtin lints: lints built into the compiler and not provided by some outside
+  source
+* plugin lints: lints created by plugins through the plugin system.
+* `rustc_interface::Config`[`register_lints`]: lints passed into the compiler
+  during construction
+
+Lints are registered via the [`LintStore::register_lint`] function. This should
+happen just once for any lint, or an ICE will occur.
+
+Once the registration is complete, we "freeze" the lint store by placing it in
+an `Lrc`. Later in the driver, it's passed into the `GlobalCtxt` constructor
+where it lives in an immutable form from then on.
+
+Lint passes are registered separately into one of the categories
+(pre-expansion, early, late, late module). Passes are registered as a closure
+-- i.e., `impl Fn() -> Box<dyn X>`, where `dyn X` is either an early or late
+lint pass trait object. When we run the lint passes, we run the closure and
+then invoke the lint pass methods. The lint pass methods take `&mut self` so
+they can keep track of state internally.
+
+#### Internal lints
+These are lints used just by the compiler or plugins like `clippy`. They can be
+found in `rustc_lint::internal`.
+
+An example of such a lint is the check that lint passes are implemented using
+the `declare_lint_pass!` macro and not by hand. This is accomplished with the
+`LINT_PASS_IMPL_WITHOUT_MACRO` lint.
+
+Registration of these lints happens in the [`rustc_lint::register_internals`]
+function which is called when constructing a new lint store inside
+[`rustc_lint::new_lint_store`].
+
+### Builtin Lints
+These are primarily described in two places: `rustc_session::lint::builtin` and
+`rustc_lint::builtin`. Often the first provides the definitions for the lints
+themselves, and the latter provides the lint pass definitions (and
+implementations), but this is not always true.
+
+The builtin lint registration happens in the [`rustc_lint::register_builtins`]
+function. Just like with internal lints, this happens inside of
+[`rustc_lint::new_lint_store`].
+
+#### Plugin lints
+This is one of the primary use cases remaining for plugins/drivers. Plugins are
+given access to the mutable `LintStore` during registration (which happens
+inside of [`rustc_interface::register_plugins`]) and they can call any
+functions they need on the `LintStore`, just like rustc code.
+
+Plugins are intended to declare lints with the `plugin` field set to true
+(e.g., by way of the [`declare_tool_lint!`] macro), but this is purely for
+diagnostics and help text; otherwise plugin lints are mostly just as first
+class as rustc builtin lints.
+
+#### Driver lints
+These are the lints provided by drivers via the `rustc_interface::Config`
+[`register_lints`] field, which is a callback. Drivers should, if finding it
+already set, call the function currently set within the callback they add. The
+best way for drivers to get access to this is by overriding the
+`Callbacks::config` function which gives them direct access to the `Config`
+structure.
+
+## Compiler lint passes are combined into one pass
+Within the compiler, for performance reasons, we usually do not register dozens
+of lint passes. Instead, we have a single lint pass of each variety (e.g.,
+`BuiltinCombinedModuleLateLintPass`) which will internally call all of the
+individual lint passes; this is because then we get the benefits of static over
+dynamic dispatch for each of the (often empty) trait methods.
+
+Ideally, we'd not have to do this, since it adds to the complexity of
+understanding the code. However, with the current type-erased lint store
+approach, it is beneficial to do so for performance reasons.
+
+[`LintStore`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html
+[`LintStore::register_lint`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_lints
+[`rustc_interface::register_plugins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/passes/fn.register_plugins.html
+[`rustc_lint::register_builtins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_builtins.html
+[`rustc_lint::register_internals`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_internals.html
+[`rustc_lint::new_lint_store`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.new_lint_store.html
+[`declare_lint!`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/macro.declare_lint.html
+[`declare_tool_lint!`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/macro.declare_tool_lint.html
+[`register_lints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/struct.Config.html#structfield.register_lints
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/translation.md b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
new file mode 100644
index 000000000..5c078ffb3
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
@@ -0,0 +1,239 @@
+# Translation
+rustc's diagnostic infrastructure supports translatable diagnostics using
+[Fluent].
+
+## Writing translatable diagnostics
+There are two ways of writing translatable diagnostics:
+
+1. For simple diagnostics, using a diagnostic (or subdiagnostic) derive
+   ("simple" diagnostics being those that don't require a lot of logic in
+   deciding to emit subdiagnostics and can therefore be represented as
+   diagnostic structs). See [the diagnostic and subdiagnostic structs
+   documentation](./diagnostic-structs.md).
+2. Using typed identifiers with `DiagnosticBuilder` APIs (in
+   `SessionDiagnostic` implementations).
+
+When adding or changing a translatable diagnostic, you don't need to worry
+about the translations, only updating the original English message. Currently,
+each crate which defines translatable diagnostics has its own Fluent resource,
+such as `parser.ftl` or `typeck.ftl`.
+
+## Fluent
+Fluent is built around the idea of "asymmetric localization", which aims to
+decouple the expressiveness of translations from the grammar of the source
+language (English in rustc's case). Prior to translation, rustc's diagnostics
+relied heavily on interpolation to build the messages shown to the users.
+Interpolated strings are hard to translate because writing a natural-sounding
+translation might require more, less, or just different interpolation than the
+English string, all of which would require changes to the compiler's source
+code to support.
+
+Diagnostic messages are defined in Fluent resources. A combined set of Fluent
+resources for a given locale (e.g. `en-US`) is known as Fluent bundle.
+
+```fluent
+typeck-address-of-temporary-taken = cannot take address of a temporary
+```
+
+In the above example, `typeck-address-of-temporary-taken` is the identifier for
+a Fluent message and corresponds to the diagnostic message in English. Other
+Fluent resources can be written which would correspond to a message in another
+language. Each diagnostic therefore has at least one Fluent message.
+
+```fluent
+typeck-address-of-temporary-taken = cannot take address of a temporary
+    .label = temporary value
+```
+
+By convention, diagnostic messages for subdiagnostics are specified as
+"attributes" on Fluent messages (additional related messages, denoted by the
+`.<attribute-name>` syntax). In the above example, `label` is an attribute of
+`typeck-address-of-temporary-taken` which corresponds to the message for the
+label added to this diagnostic.
+
+Diagnostic messages often interpolate additional context into the message shown
+to the user, such as the name of a type or of a variable. Additional context to
+Fluent messages is provided as an "argument" to the diagnostic.
+
+```fluent
+typeck-struct-expr-non-exhaustive =
+    cannot create non-exhaustive {$what} using struct expression
+```
+
+In the above example, the Fluent message refers to an argument named `what`
+which is expected to exist (how arguments are provided to diagnostics is
+discussed in detail later).
+
+You can consult the [Fluent] documentation for other usage examples of Fluent
+and its syntax.
+
+### Guidelines for writing translatable messages
+For a message to be translatable into different languages, all of the
+information required by any language must be provided to the diagnostic as an
+argument (not just the information required in the English message).
+
+As the compiler team gain more experience writing diagnostics that have all of
+the information necessary to be translated into different languages, this page
+will be updated with more guidance. For now, the [Fluent] documentation has
+excellent examples of translating messages into different locales and the
+information that needs to be provided by the code to do so.
+
+### Compile-time validation and typed identifiers
+rustc's Fluent resources for the default locale (`en-US`) are in the
+[`compiler/rustc_error_messages/locales/en-US`] directory. Currently, each crate
+which defines translatable diagnostics has its own Fluent resource, such as
+`parser.ftl` or `typeck.ftl`.
+
+rustc's `fluent_messages` macro performs compile-time validation of Fluent
+resources and generates code to make it easier to refer to Fluent messages in
+diagnostics.
+
+Compile-time validation of Fluent resources will emit any parsing errors
+from Fluent resources while building the compiler, preventing invalid Fluent
+resources from causing panics in the compiler. Compile-time validation also
+emits an error if multiple Fluent messages have the same identifier.
+
+In `rustc_error_messages`, `fluent_messages` also generates a constant for each
+Fluent message which can be used to refer to messages when emitting
+diagnostics and guarantee that the message exists.
+
+```rust
+fluent_messages! {
+    typeck => "../locales/en-US/typeck.ftl",
+}
+```
+
+For example, given the following Fluent...
+
+```fluent
+typeck-field-multiply-specified-in-initializer =
+    field `{$ident}` specified more than once
+    .label = used more than once
+    .label-previous-use = first use of `{$ident}`
+```
+
+...then the `fluent_messages` macro will generate:
+
+```rust
+pub static DEFAULT_LOCALE_RESOURCES: &'static [&'static str] = &[
+    include_str!("../locales/en-US/typeck.ftl"),
+];
+
+mod fluent_generated {
+    mod typeck {
+        pub const field_multiply_specified_in_initializer: DiagnosticMessage =
+            DiagnosticMessage::new("typeck-field-multiply-specified-in-initializer");
+        pub const label: SubdiagnosticMessage =
+            SubdiagnosticMessage::attr("label");
+        pub const label_previous_use: SubdiagnosticMessage =
+            SubdiagnosticMessage::attr("previous-use-label");
+    }
+}
+```
+
+`rustc_error_messages::fluent_generated` is re-exported and primarily used as
+`rustc_errors::fluent`.
+
+```rust
+use rustc_errors::fluent;
+let mut err = sess.struct_span_err(span, fluent::typeck::field_multiply_specified_in_initializer);
+err.span_label(span, fluent::typeck::label);
+err.span_label(previous_use_span, fluent::typeck::previous_use_label);
+err.emit();
+```
+
+When emitting a diagnostic, these constants can be used like shown above.
+
+## Internals
+Various parts of rustc's diagnostic internals are modified in order to support
+translation.
+
+### Messages
+All of rustc's traditional diagnostic APIs (e.g. `struct_span_err` or `note`)
+take any message that can be converted into a `DiagnosticMessage` (or
+`SubdiagnosticMessage`).
+
+[`rustc_error_messages::DiagnosticMessage`] can represent legacy non-translatable
+diagnostic messages and translatable messages. Non-translatable messages are
+just `String`s. Translatable messages are just a `&'static str` with the
+identifier of the Fluent message (sometimes with an additional `&'static str`
+with an attribute).
+
+`DiagnosticMessage` never needs to be interacted with directly:
+`DiagnosticMessage` constants are created for each diagnostic message in a
+Fluent resource (described in more detail below), or `DiagnosticMessage`s will
+either be created in the macro-generated code of a diagnostic derive.
+
+`rustc_error_messages::SubdiagnosticMessage` is similar, it can correspond to a
+legacy non-translatable diagnostic message or the name of an attribute to a
+Fluent message. Translatable `SubdiagnosticMessage`s must be combined with a
+`DiagnosticMessage` (using `DiagnosticMessage::with_subdiagnostic_message`) to
+be emitted (an attribute name on its own is meaningless without a corresponding
+message identifier, which is what `DiagnosticMessage` provides).
+
+Both `DiagnosticMessage` and `SubdiagnosticMessage` implement `Into` for any
+type that can be converted into a string, and converts these into
+non-translatable diagnostics - this keeps all existing diagnostic calls
+working.
+
+### Arguments
+Additional context for Fluent messages which are interpolated into message
+contents needs to be provided to translatable diagnostics.
+
+Diagnostics have a `set_arg` function that can be used to provide this
+additional context to a diagnostic.
+
+Arguments have both a name (e.g. "what" in the earlier example) and a value.
+Argument values are represented using the `DiagnosticArgValue` type, which is
+just a string or a number. rustc types can implement `IntoDiagnosticArg` with
+conversion into a string or a number, common types like `Ty<'tcx>` already
+have such implementations.
+
+`set_arg` calls are handled transparently by diagnostic derives but need to be
+added manually when using diagnostic builder APIs.
+
+### Loading
+rustc makes a distinction between the "fallback bundle" for `en-US` that is used
+by default and when another locale is missing a message; and the primary fluent
+bundle which is requested by the user.
+
+Diagnostic emitters implement the `Emitter` trait which has two functions for
+accessing the fallback and primary fluent bundles (`fallback_fluent_bundle` and
+`fluent_bundle` respectively).
+
+`Emitter` also has member functions with default implementations for performing
+translation of a `DiagnosticMessage` using the results of
+`fallback_fluent_bundle` and `fluent_bundle`.
+
+All of the emitters in rustc load the fallback Fluent bundle lazily, only
+reading Fluent resources and parsing them when an error message is first being
+translated (for performance reasons - it doesn't make sense to do this if no
+error is being emitted). `rustc_error_messages::fallback_fluent_bundle` returns
+a `std::lazy::Lazy<FluentBundle>` which is provided to emitters and evaluated
+in the first call to `Emitter::fallback_fluent_bundle`.
+
+The primary Fluent bundle (for the user's desired locale) is expected to be
+returned by `Emitter::fluent_bundle`. This bundle is used preferentially when
+translating messages, the fallback bundle is only used if the primary bundle is
+missing a message or not provided.
+
+As of <!-- date: 2022-06 --> June 2022, there are no locale bundles
+distributed with the compiler, but mechanisms are implemented for loading
+bundles.
+
+- `-Ztranslate-additional-ftl` can be used to load a specific resource as the
+  primary bundle for testing purposes.
+- `-Ztranslate-lang` can be provided a language identifier (something like
+  `en-US`) and will load any Fluent resources found in
+  `$sysroot/share/locale/$locale/` directory (both the user provided
+  sysroot and any sysroot candidates).
+
+Primary bundles are not currently loaded lazily and if requested will be loaded
+at the start of compilation regardless of whether an error occurs. Lazily
+loading primary bundles is possible if it can be assumed that loading a bundle
+won't fail. Bundle loading can fail if a requested locale is missing, Fluent
+files are malformed, or a message is duplicated in multiple resources.
+
+[Fluent]: https://projectfluent.org
+[`compiler/rustc_error_messages/locales/en-US`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_error_messages/locales/en-US
+[`rustc_error_messages::DiagnosticMessage`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_error_messages/enum.DiagnosticMessage.html
diff --git a/src/doc/rustc-dev-guide/src/early-late-bound.md b/src/doc/rustc-dev-guide/src/early-late-bound.md
new file mode 100644
index 000000000..29b2136b4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/early-late-bound.md
@@ -0,0 +1,107 @@
+# Early and Late Bound Variables
+
+In Rust, item definitions (like `fn`) can often have generic parameters, which
+are always [_universally_ quantified][quant]. That is, if you have a function
+like
+
+```rust
+fn foo<T>(x: T) { }
+```
+
+this function is defined "for all T" (not "for some specific T", which would be
+[_existentially_ quantified][quant]).
+
+[quant]: ./appendix/background.md#quantified
+
+While Rust *items* can be quantified over types, lifetimes, and constants, the
+types of values in Rust are only ever quantified over lifetimes. So you can
+have a type like `for<'a> fn(&'a u32)`, which represents a function pointer
+that takes a reference with any lifetime, or `for<'a> dyn Trait<'a>`, which is
+a `dyn` trait for a trait implemented for any lifetime; but we have no type
+like `for<T> fn(T)`, which would be a function that takes a value of *any type*
+as a parameter. This is a consequence of monomorphization -- to support a value
+of type `for<T> fn(T)`, we would need a single function pointer that can be
+used for a parameter of any type, but in Rust we generate customized code for
+each parameter type.
+
+One consequence of this asymmetry is a weird split in how we represent some
+generic types: _early-_ and _late-_ bound parameters.
+Basically, if we cannot represent a type (e.g. a universally quantified type),
+we have to bind it _early_ so that the unrepresentable type is never around.
+
+Consider the following example:
+
+```rust,ignore
+fn foo<'a, 'b, T>(x: &'a u32, y: &'b T) where T: 'b { ... }
+```
+
+We cannot treat `'a`, `'b`, and `T` in the same way.  Types in Rust can't have
+`for<T> { .. }`, only `for<'a> {...}`, so whenever you reference `foo` the type
+you get back can't be `for<'a, 'b, T> fn(&'a u32, y: &'b T)`. Instead, the `T`
+must be substituted early. In particular, you have:
+
+```rust,ignore
+let x = foo; // T, 'b have to be substituted here
+x(...);      // 'a substituted here, at the point of call
+x(...);      // 'a substituted here with a different value
+```
+
+## Early-bound parameters
+
+Early-bound parameters in rustc are identified by an index, stored in the
+[`ParamTy`] struct for types or the [`EarlyBoundRegion`] struct for lifetimes.
+The index counts from the outermost declaration in scope. This means that as you
+add more binders inside, the index doesn't change.
+
+For example,
+
+```rust,ignore
+trait Foo<T> {
+  type Bar<U> = (Self, T, U);
+}
+```
+
+Here, the type `(Self, T, U)` would be `($0, $1, $2)`, where `$N` means a
+[`ParamTy`] with the index of `N`.
+
+In rustc, the [`Generics`] structure carries this information. So the
+[`Generics`] for `Bar` above would be just like for `U` and would indicate the
+'parent' generics of `Foo`, which declares `Self` and `T`.  You can read more
+in [this chapter](./generics.md).
+
+[`ParamTy`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamTy.html
+[`EarlyBoundRegion`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.EarlyBoundRegion.html
+[`Generics`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Generics.html
+
+## Late-bound parameters
+
+Late-bound parameters in `rustc` are handled quite differently (they are also
+specialized to lifetimes since, right now, only late-bound lifetimes are
+supported, though with GATs that has to change). We indicate their potential
+presence by a [`Binder`] type. The [`Binder`] doesn't know how many variables
+there are at that binding level. This can only be determined by walking the
+type itself and collecting them. So a type like `for<'a, 'b> ('a, 'b)` would be
+`for (^0.a, ^0.b)`. Here, we just write `for` because we don't know the names
+of the things bound within.
+
+Moreover, a reference to a late-bound lifetime is written `^0.a`:
+
+- The `0` is the index; it identifies that this lifetime is bound in the
+  innermost binder (the `for`).
+- The `a` is the "name"; late-bound lifetimes in rustc are identified by a
+  "name" -- the [`BoundRegionKind`] enum. This enum can contain a
+  [`DefId`][defid] or it might have various "anonymous" numbered names. The
+  latter arise from types like `fn(&u32, &u32)`, which are equivalent to
+  something like `for<'a, 'b> fn(&'a u32, &'b u32)`, but the names of those
+  lifetimes must be generated.
+
+This setup of not knowing the full set of variables at a binding level has some
+advantages and some disadvantages. The disadvantage is that you must walk the
+type to find out what is bound at the given level and so forth. The advantage
+is primarily that, when constructing types from Rust syntax, if we encounter
+anonymous regions like in `fn(&u32)`, we just create a fresh index and don't have
+to update the binder.
+
+[`Binder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Binder.html
+[`BoundRegionKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.BoundRegionKind.html
+[defid]: ./hir.html#identifiers-in-the-hir
diff --git a/src/doc/rustc-dev-guide/src/feature-gate-ck.md b/src/doc/rustc-dev-guide/src/feature-gate-ck.md
new file mode 100644
index 000000000..c17747a11
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/feature-gate-ck.md
@@ -0,0 +1,3 @@
+# Feature Gate Checking
+
+**TODO**: this chapter [#1158](https://github.com/rust-lang/rustc-dev-guide/issues/1158)
diff --git a/src/doc/rustc-dev-guide/src/feature-gates.md b/src/doc/rustc-dev-guide/src/feature-gates.md
new file mode 100644
index 000000000..229281f2f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/feature-gates.md
@@ -0,0 +1,111 @@
+# Feature Gates
+
+This chapter is intended to provide basic help for adding, removing, and
+modifying feature gates.
+
+
+## Adding a feature gate
+
+See ["Stability in code"] for help with adding a new feature; this section just
+covers how to add the feature gate *declaration*.
+
+Add a feature gate declaration to `rustc_feature/src/active.rs` in the active
+`declare_features` block:
+
+```rust,ignore
+/// description of feature
+(active, $feature_name, "$current_nightly_version", Some($tracking_issue_number), $edition)
+```
+
+where `$edition` has the type `Option<Edition>`, and is typically
+just `None`.
+
+For example:
+
+```rust,ignore
+/// Allows defining identifiers beyond ASCII.
+(active, non_ascii_idents, "1.0.0", Some(55467), None),
+```
+
+Features can be marked as incomplete, and trigger the warn-by-default [`incomplete_features` lint]
+by setting their type to `incomplete`:
+
+```rust,ignore
+/// Allows unsized rvalues at arguments and parameters.
+(incomplete, unsized_locals, "1.30.0", Some(48055), None),
+```
+
+When added, the current version should be the one for the current nightly.
+Once the feature is moved to `accepted.rs`, the version is changed to that
+nightly version.
+
+
+## Removing a feature gate
+
+[removing]: #removing-a-feature-gate
+
+To remove a feature gate, follow these steps:
+
+1. Remove the feature gate declaration in `rustc_feature/src/active.rs`.
+   It will look like this:
+
+   ```rust,ignore
+   /// description of feature
+   (active, $feature_name, "$version", Some($tracking_issue_number), $edition)
+   ```
+
+2. Add a modified version of the feature gate declaration that you just
+   removed to `rustc_feature/src/removed.rs`:
+
+   ```rust,ignore
+   /// description of feature
+   (removed, $old_feature_name, "$version", Some($tracking_issue_number), $edition,
+    Some("$why_it_was_removed"))
+   ```
+
+
+## Renaming a feature gate
+
+[renaming]: #renaming-a-feature-gate
+
+To rename a feature gate, follow these steps (the first two are the same steps
+to follow when [removing a feature gate][removing]):
+
+1. Remove the old feature gate declaration in `rustc_feature/src/active.rs`.
+   It will look like this:
+
+   ```rust,ignore
+   /// description of feature
+   (active, $old_feature_name, "$version", Some($tracking_issue_number), $edition)
+   ```
+
+2. Add a modified version of the old feature gate declaration that you just
+   removed to `rustc_feature/src/removed.rs`:
+
+   ```rust,ignore
+   /// description of feature
+   /// Renamed to `$new_feature_name`
+   (removed, $old_feature_name, "$version", Some($tracking_issue_number), $edition,
+    Some("renamed to `$new_feature_name`"))
+   ```
+
+3. Add a feature gate declaration with the new name to
+   `rustc_feature/src/active.rs`. It should look very similar to the old
+   declaration:
+
+   ```rust,ignore
+   /// description of feature
+   (active, $new_feature_name, "$version", Some($tracking_issue_number), $edition)
+   ```
+
+
+## Stabilizing a feature
+
+See ["Updating the feature-gate listing"] in the "Stabilizing Features" chapter
+for instructions. There are additional steps you will need to take beyond just
+updating the declaration!
+
+
+["Stability in code"]: ./implementing_new_features.md#stability-in-code
+[`incomplete_features` lint]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#incomplete-features
+["Updating the feature-gate listing"]: ./stabilization_guide.md#updating-the-feature-gate-listing
diff --git a/src/doc/rustc-dev-guide/src/generic_arguments.md b/src/doc/rustc-dev-guide/src/generic_arguments.md
new file mode 100644
index 000000000..c9911acf5
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/generic_arguments.md
@@ -0,0 +1,50 @@
+# Generic arguments
+A `ty::subst::GenericArg<'tcx>` represents some entity in the type system: a type
+(`Ty<'tcx>`), lifetime (`ty::Region<'tcx>`) or constant (`ty::Const<'tcx>`).
+`GenericArg` is used to perform substitutions of generic parameters for concrete
+arguments, such as when calling a function with generic parameters explicitly
+with type arguments. Substitutions are represented using the
+[`Subst` type](#subst) as described below.
+
+## `Subst`
+`ty::subst::Subst<'tcx>` is intuitively simply a slice of `GenericArg<'tcx>`s,
+acting as an ordered list of substitutions from generic parameters to
+concrete arguments (such as types, lifetimes and consts).
+
+For example, given a `HashMap<K, V>` with two type parameters, `K` and `V`, an
+instantiation of the parameters, for example `HashMap<i32, u32>`, would be
+represented by the substitution `&'tcx [tcx.types.i32, tcx.types.u32]`.
+
+`Subst` provides various convenience methods to instantiate substitutions
+given item definitions, which should generally be used rather than explicitly
+constructing such substitution slices.
+
+## `GenericArg`
+The actual `GenericArg` struct is optimised for space, storing the type, lifetime or
+const as an interned pointer containing a tag identifying its kind (in the
+lowest 2 bits). Unless you are working with the `Subst` implementation
+specifically, you should generally not have to deal with `GenericArg` and instead
+make use of the safe [`GenericArgKind`](#genericargkind) abstraction.
+
+## `GenericArgKind`
+As `GenericArg` itself is not type-safe, the `GenericArgKind` enum provides a more
+convenient and safe interface for dealing with generic arguments. An
+`GenericArgKind` can be converted to a raw `GenericArg` using `GenericArg::from()`
+(or simply `.into()` when the context is clear). As mentioned earlier, substitution
+lists store raw `GenericArg`s, so before dealing with them, it is preferable to
+convert them to `GenericArgKind`s first. This is done by calling the `.unpack()`
+method.
+
+```rust,ignore
+// An example of unpacking and packing a generic argument.
+fn deal_with_generic_arg<'tcx>(generic_arg: GenericArg<'tcx>) -> GenericArg<'tcx> {
+    // Unpack a raw `GenericArg` to deal with it safely.
+    let new_generic_arg: GenericArgKind<'tcx> = match generic_arg.unpack() {
+        GenericArgKind::Type(ty) => { /* ... */ }
+        GenericArgKind::Lifetime(lt) => { /* ... */ }
+        GenericArgKind::Const(ct) => { /* ... */ }
+    };
+    // Pack the `GenericArgKind` to store it in a substitution list.
+    new_generic_arg.into()
+}
+```
diff --git a/src/doc/rustc-dev-guide/src/generics.md b/src/doc/rustc-dev-guide/src/generics.md
new file mode 100644
index 000000000..13549b2fb
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/generics.md
@@ -0,0 +1,144 @@
+# Generics and substitutions
+
+Given a generic type `MyType<A, B, …>`, we may want to swap out the generics `A, B, …` for some
+other types (possibly other generics or concrete types). We do this a lot while doing type
+inference, type checking, and trait solving. Conceptually, during these routines, we may find out
+that one type is equal to another type and want to swap one out for the other and then swap that out
+for another type and so on until we eventually get some concrete types (or an error).
+
+In rustc this is done using the `SubstsRef` that we mentioned above (“substs” = “substitutions”).
+Conceptually, you can think of `SubstsRef` as a list of types that are to be substituted for the
+generic type parameters of the ADT.
+
+`SubstsRef` is a type alias of `&'tcx List<GenericArg<'tcx>>` (see [`List` rustdocs][list]).
+[`GenericArg`] is essentially a space-efficient wrapper around [`GenericArgKind`], which is an enum
+indicating what kind of generic the type parameter is (type, lifetime, or const).  Thus, `SubstsRef`
+is conceptually like a `&'tcx [GenericArgKind<'tcx>]` slice (but it is actually a `List`).
+
+[list]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.List.html
+[`GenericArg`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/subst/struct.GenericArg.html
+[`GenericArgKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/subst/enum.GenericArgKind.html
+
+So why do we use this `List` type instead of making it really a slice? It has the length "inline",
+so `&List` is only 32 bits. As a consequence, it cannot be "subsliced" (that only works if the
+length is out of line).
+
+This also implies that you can check two `List`s for equality via `==` (which would be not be
+possible for ordinary slices). This is precisely because they never represent a "sub-list", only the
+complete `List`, which has been hashed and interned.
+
+So pulling it all together, let’s go back to our example above:
+
+```rust,ignore
+struct MyStruct<T>
+```
+
+- There would be an `AdtDef` (and corresponding `DefId`) for `MyStruct`.
+- There would be a `TyKind::Param` (and corresponding `DefId`) for `T` (more later).
+- There would be a `SubstsRef` containing the list `[GenericArgKind::Type(Ty(T))]`
+    - The `Ty(T)` here is my shorthand for entire other `ty::Ty` that has `TyKind::Param`, which we
+      mentioned in the previous point.
+- This is one `TyKind::Adt` containing the `AdtDef` of `MyStruct` with the `SubstsRef` above.
+
+Finally, we will quickly mention the
+[`Generics`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Generics.html) type. It
+is used to give information about the type parameters of a type.
+
+### Unsubstituted Generics
+
+So above, recall that in our example the `MyStruct` struct had a generic type `T`. When we are (for
+example) type checking functions that use `MyStruct`, we will need to be able to refer to this type
+`T` without actually knowing what it is. In general, this is true inside all generic definitions: we
+need to be able to work with unknown types. This is done via `TyKind::Param` (which we mentioned in
+the example above).
+
+Each `TyKind::Param` contains two things: the name and the index. In general, the index fully
+defines the parameter and is used by most of the code. The name is included for debug print-outs.
+There are two reasons for this. First, the index is convenient, it allows you to include into the
+list of generic arguments when substituting. Second, the index is more robust. For example, you
+could in principle have two distinct type parameters that use the same name, e.g. `impl<A> Foo<A> {
+fn bar<A>() { .. } }`, although the rules against shadowing make this difficult (but those language
+rules could change in the future).
+
+The index of the type parameter is an integer indicating its order in the list of the type
+parameters. Moreover, we consider the list to include all of the type parameters from outer scopes.
+Consider the following example:
+
+```rust,ignore
+struct Foo<A, B> {
+  // A would have index 0
+  // B would have index 1
+
+  .. // some fields
+}
+impl<X, Y> Foo<X, Y> {
+  fn method<Z>() {
+    // inside here, X, Y and Z are all in scope
+    // X has index 0
+    // Y has index 1
+    // Z has index 2
+  }
+}
+```
+
+When we are working inside the generic definition, we will use `TyKind::Param` just like any other
+`TyKind`; it is just a type after all. However, if we want to use the generic type somewhere, then
+we will need to do substitutions.
+
+For example suppose that the `Foo<A, B>` type from the previous example has a field that is a
+`Vec<A>`. Observe that `Vec` is also a generic type. We want to tell the compiler that the type
+parameter of `Vec` should be replaced with the `A` type parameter of `Foo<A, B>`. We do that with
+substitutions:
+
+```rust,ignore
+struct Foo<A, B> { // Adt(Foo, &[Param(0), Param(1)])
+  x: Vec<A>, // Adt(Vec, &[Param(0)])
+  ..
+}
+
+fn bar(foo: Foo<u32, f32>) { // Adt(Foo, &[u32, f32])
+  let y = foo.x; // Vec<Param(0)> => Vec<u32>
+}
+```
+
+This example has a few different substitutions:
+
+- In the definition of `Foo`, in the type of the field `x`, we replace `Vec`'s type parameter with
+  `Param(0)`, the first parameter of `Foo<A, B>`, so that the type of `x` is `Vec<A>`.
+- In the function `bar`, we specify that we want a `Foo<u32, f32>`. This means that we will
+  substitute `Param(0)` and `Param(1)` with `u32` and `f32`.
+- In the body of `bar`, we access `foo.x`, which has type `Vec<Param(0)>`, but `Param(0)` has been
+  substituted for `u32`, so `foo.x` has type `Vec<u32>`.
+
+Let’s look a bit more closely at that last substitution to see why we use indexes. If we want to
+find the type of `foo.x`, we can get generic type of `x`, which is `Vec<Param(0)>`. Now we can take
+the index `0` and use it to find the right type substitution: looking at `Foo`'s `SubstsRef`, we
+have the list `[u32, f32]` , since we want to replace index `0`, we take the 0-th index of this
+list, which is `u32`. Voila!
+
+You may have a couple of followup questions…
+
+ **`type_of`** How do we get the “generic type of `x`"? You can get the type of pretty much anything
+ with the   `tcx.type_of(def_id)` query. In this case, we would pass the `DefId` of the field `x`.
+ The `type_of` query always returns the definition with the generics that are in scope of the
+ definition. For example, `tcx.type_of(def_id_of_my_struct)` would return the “self-view” of
+ `MyStruct`: `Adt(Foo, &[Param(0), Param(1)])`.
+
+**`subst`** How do we actually do the substitutions? There is a function for that too! You use
+[`subst`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/subst/trait.Subst.html) to
+replace a `SubstRef` with another list of types.
+
+[Here is an example of actually using `subst` in the compiler][substex].  The exact details are not
+too important, but in this piece of code, we happen to be converting from the `rustc_hir::Ty` to
+a real `ty::Ty`. You can see that we first get some substitutions (`substs`).  Then we call
+`type_of` to get a type and call `ty.subst(substs)` to get a new version of `ty` with
+the substitutions made.
+
+[substex]: https://github.com/rust-lang/rust/blob/597f432489f12a3f33419daa039ccef11a12c4fd/src/librustc_typeck/astconv.rs#L942-L953
+
+**Note on indices:** It is possible for the indices in `Param` to not match with what we expect. For
+example, the index could be out of bounds or it could be the index of a lifetime when we were
+expecting a type. These sorts of errors would be caught earlier in the compiler when translating
+from a `rustc_hir::Ty` to a `ty::Ty`. If they occur later, that is a compiler bug.
+
+
diff --git a/src/doc/rustc-dev-guide/src/getting-started.md b/src/doc/rustc-dev-guide/src/getting-started.md
new file mode 100644
index 000000000..b4dc11a68
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/getting-started.md
@@ -0,0 +1,314 @@
+# Getting Started
+
+<!-- toc -->
+
+This documentation is _not_ intended to be comprehensive; it is meant to be a
+quick guide for the most useful things. For more information, [see this
+chapter on how to build and run the compiler](./building/how-to-build-and-run.md).
+
+## Asking Questions
+
+The compiler team (or `t-compiler`) usually hangs out in Zulip [in this
+"stream"][z]; it will be easiest to get questions answered there.
+
+[z]: https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler
+
+**Please ask questions!** A lot of people report feeling that they are "wasting
+expert time", but nobody on `t-compiler` feels this way. Contributors are
+important to us.
+
+Also, if you feel comfortable, prefer public topics, as this means others can
+see the questions and answers, and perhaps even integrate them back into this
+guide :)
+
+### Experts
+
+Not all `t-compiler` members are experts on all parts of `rustc`; it's a pretty
+large project.  To find out who has expertise on different parts of the
+compiler, [consult this "experts map"][map].
+
+It's not perfectly complete, though, so please also feel free to ask questions
+even if you can't figure out who to ping.
+
+[map]: https://github.com/rust-lang/compiler-team/blob/master/content/experts/map.toml
+
+### Etiquette
+
+We do ask that you be mindful to include as much useful information as you can
+in your question, but we recognize this can be hard if you are unfamiliar with
+contributing to Rust.
+
+Just pinging someone without providing any context can be a bit annoying and
+just create noise, so we ask that you be mindful of the fact that the
+`t-compiler` folks get a lot of pings in a day.
+
+## Cloning and Building
+
+### System Requirements
+
+Internet access is required.
+
+The most notable software requirement is that you will need Python 2 or 3, but
+there are various others.
+
+The following hardware is recommended.
+* 30GB+ of free disk space.
+* 8GB+ RAM
+* 2+ cores
+
+More powerful machines will lead to much faster builds. There are various
+strategies to work around lesser hardware in the following chapters.
+
+See [this chapter][prereqs] for more details about software and hardware prerequisites.
+
+[prereqs]: ./building/prerequisites.md
+
+### Cloning
+
+You can just do a normal git clone:
+
+```sh
+git clone https://github.com/rust-lang/rust.git
+cd rust
+```
+
+### `x.py` Intro
+
+`rustc` is a [bootstrapping] compiler, which makes it more complex than a
+typical Rust program. As a result, you cannot use Cargo to build it. Instead
+you must use the special tool `x.py`. It is used for the things Cargo is
+normally used for: building, testing, creating releases, formatting, etc.
+
+[bootstrapping]: ./building/bootstrapping.md
+
+### Configuring the Compiler
+
+In the top level of the repo:
+
+```sh
+$ ./x.py setup
+```
+
+This will do some initialization and walk you through an interactive setup to
+create `config.toml`, the primary configuration file.
+
+See [this chapter][config] for more info about configuration.
+
+[config]: ./building/how-to-build-and-run.md#create-a-configtoml
+
+### Common `x.py` commands
+
+Here are the basic invocations of the `x.py` commands most commonly used when
+working on `rustc`, `std`, `rustdoc`, and other tools.
+
+| Command | When to use it |
+| --- | --- |
+| `./x.py check` | Quick check to see if most things compile; [rust-analyzer can run this automatically for you][rust-analyzer] |
+| `./x.py build` | Builds `rustc`, `std`, and `rustdoc` |
+| `./x.py test` | Runs all tests |
+| `./x.py fmt` | Formats all code |
+
+As written, these commands are reasonable starting points. However, there are
+additional options and arguments for each of them that are worth learning for
+serious development work. In particular, `./x.py build` and `./x.py test`
+provide many ways to compile or test a subset of the code, which can save a lot
+of time.
+
+[rust-analyzer]: ./building/suggested.html#configuring-rust-analyzer-for-rustc
+
+See the chapters on [building](./building/how-to-build-and-run.md),
+[testing](./tests/intro.md), and [rustdoc](./rustdoc.md) for more details.
+
+### Contributing code to other Rust projects
+
+There are a bunch of other projects that you can contribute to outside of the
+`rust-lang/rust` repo, including `clippy`, `miri`, `chalk`, and many others.
+
+These repos might have their own contributing guidelines and procedures. Many
+of them are owned by working groups (e.g. `chalk` is largely owned by
+WG-traits). For more info, see the documentation in those repos' READMEs.
+
+### Other ways to contribute
+
+There are a bunch of other ways you can contribute, especially if you don't
+feel comfortable jumping straight into the large `rust-lang/rust` codebase.
+
+The following tasks are doable without much background knowledge but are
+incredibly helpful:
+
+- [Cleanup crew][iceb]: find minimal reproductions of ICEs, bisect
+  regressions, etc. This is a way of helping that saves a ton of time for
+  others to fix an error later.
+- [Writing documentation][wd]: if you are feeling a bit more intrepid, you could try
+  to read a part of the code and write doc comments for it. This will help you
+  to learn some part of the compiler while also producing a useful artifact!
+- [Working groups][wg]: there are a bunch of working groups on a wide variety
+  of rust-related things.
+
+[iceb]: ./notification-groups/cleanup-crew.md
+[wd]: ./contributing.md#writing-documentation
+[wg]: https://rust-lang.github.io/compiler-team/working-groups/
+
+## Contributor Procedures
+
+There are some official procedures to know about. This is a tour of the
+highlights, but there are a lot more details, which we will link to below.
+
+### Code Review
+
+When you open a PR on the `rust-lang/rust` repo, a bot called `@rust-highfive` will
+automatically assign a reviewer to the PR based on which files you changed.
+The reviewer is the person that will approve the PR to be tested and merged.
+If you want a specific reviewer (e.g. a team member you've been working with),
+you can specifically request them by writing `r? @user` (e.g. `r? @jyn514`) in
+either the original post or a followup comment
+(you can see [this comment][r?] for example).
+
+Please note that the reviewers are humans, who for the most part work on `rustc`
+in their free time. This means that they can take some time to respond and review
+your PR. It also means that reviewers can miss some PRs that are assigned to them.
+
+To try to move PRs forward, the Triage WG regularly goes through all PRs that
+are waiting for review and haven't been discussed for at least 2 weeks. If you
+don't get a review within 2 weeks, feel free to ask the Triage WG on
+Zulip ([#t-release/triage]). They have knowledge of when to ping, who might be
+on vacation, etc.
+
+The reviewer may request some changes using the GitHub code review interface.
+They may also request special procedures (such as a [crater] run; [see
+below][break]) for some PRs.
+
+[r?]: https://github.com/rust-lang/rust/pull/78133#issuecomment-712692371
+[#t-release/triage]: https://rust-lang.zulipchat.com/#narrow/stream/242269-t-release.2Ftriage
+[break]: #breaking-changes
+
+When the PR is ready to be merged, the reviewer will issue a command to
+`@bors`, the CI bot. Usually, this is `@bors r+` or `@bors r=user` to approve
+a PR (there are few other commands, but they are less relevant here).
+You can see [this comment][r+] for example. This puts the PR in [bors's queue][bors]
+to be tested and merged. Be patient; this can take a while and the queue can
+sometimes be long. PRs are never merged by hand.
+
+[r+]: https://github.com/rust-lang/rust/pull/78133#issuecomment-712726339
+[bors]: https://bors.rust-lang.org/queue/rust
+
+### Bug Fixes or "Normal" code changes
+
+For most PRs, no special procedures are needed. You can just open a PR, and it
+will be reviewed, approved, and merged. This includes most bug fixes,
+refactorings, and other user-invisible changes. The next few sections talk
+about exceptions to this rule.
+
+Also, note that it is perfectly acceptable to open WIP PRs or GitHub [Draft
+PRs][draft]. Some people prefer to do this so they can get feedback along the
+way or share their code with a collaborator. Others do this so they can utilize
+the CI to build and test their PR (e.g. if you are developing on a laptop).
+
+[draft]: https://github.blog/2019-02-14-introducing-draft-pull-requests/
+
+### New Features
+
+Rust has strong backwards-compatibility guarantees. Thus, new features can't
+just be implemented directly in stable Rust. Instead, we have 3 release
+channels: stable, beta, and nightly.
+
+- **Stable**: this is the latest stable release for general usage.
+- **Beta**: this is the next release (will be stable within 6 weeks).
+- **Nightly**: follows the `master` branch of the repo. This is the only
+  channel where unstable, incomplete, or experimental features are usable with
+  feature gates.
+
+In order to implement a new feature, usually you will need to go through [the
+RFC process][rfc] to propose a design, have discussions, etc. In some cases,
+small features can be added with only an FCP ([see below][break]). If in doubt, ask the
+compiler, language, or libs team (whichever is most relevant).
+
+[rfc]: https://github.com/rust-lang/rfcs/blob/master/README.md
+
+After a feature is approved to be added, a tracking issue is created on the
+`rust-lang/rust` repo, which tracks the progress towards the implementation of
+the feature, any bugs reported, and eventually stabilization.
+
+The feature then needs to be implemented behind a feature gate, which prevents
+it from being accidentally used.
+
+Finally, somebody may propose stabilizing the feature in an upcoming version of
+Rust. This requires a Final Comment Period ([see below][break]) to get the
+approval of the relevant teams.
+
+After that, the feature gate can be removed and the feature turned on for all users.
+
+For more details on this process, see [this chapter on implementing new
+features.](./implementing_new_features.md)
+
+### Breaking Changes
+
+As mentioned above, Rust has strong backwards-compatibility guarantees. To this
+end, we are reluctant to make breaking changes. However, sometimes they are
+needed to correct compiler bugs (e.g. code that compiled but should not) or
+make progress on some features.
+
+Depending on the scale of the breakage, there are a few different actions that
+can be taken.  If the reviewer believes the breakage is very minimal (i.e. very
+unlikely to be actually encountered by users), they may just merge the change.
+More often, they will request a Final Comment Period (FCP), which calls for
+rough consensus among the members of a relevant team. The team members can
+discuss the issue and either accept, reject, or request changes on the PR.
+
+If the scale of breakage is large, a deprecation warning may be needed. This is
+a warning that the compiler will display to users whose code will break in the
+future. After some time, an FCP can be used to move forward with the actual
+breakage.
+
+If the scale of breakage is unknown, a team member or contributor may request a
+[crater] run. This is a bot that will compile all crates.io crates and many
+public github repos with the compiler with your changes. A report will then be
+generated with crates that ceased to compile with or began to compile with your
+changes. Crater runs can take a few days to complete.
+
+[crater]: https://github.com/rust-lang/crater
+
+### Major Changes
+
+The compiler team has a special process for large changes, whether or not they
+cause breakage. This process is called a Major Change Proposal (MCP). MCP is a
+relatively lightweight mechanism for getting feedback on large changes to the
+compiler (as opposed to a full RFC or a design meeting with the team).
+
+Example of things that might require MCPs include major refactorings, changes
+to important types, or important changes to how the compiler does something, or
+smaller user-facing changes.
+
+**When in doubt, ask on [zulip][z]. It would be a shame to put a lot of work
+into a PR that ends up not getting merged!** [See this document][mcpinfo] for
+more info on MCPs.
+
+[mcpinfo]: https://forge.rust-lang.org/compiler/mcp.html
+
+### Performance
+
+Compiler performance is important. We have put a lot of effort over the last
+few years into [gradually improving it][perfdash].
+
+[perfdash]: https://perf.rust-lang.org/dashboard.html
+
+If you suspect that your change may cause a performance regression (or
+improvement), you can request a "perf run" (your reviewer may also request one
+before approving). This is yet another bot that will compile a collection of
+benchmarks on a compiler with your changes. The numbers are reported
+[here][perf], and you can see a comparison of your changes against the latest
+master.
+
+For an introduction to the performance of Rust code in general
+which would also be useful in rustc development, see [The Rust Performance Book].
+
+[perf]: https://perf.rust-lang.org
+[The Rust Performance Book]: https://nnethercote.github.io/perf-book/
+
+## Other Resources
+
+- This guide: talks about how `rustc` works
+- [The t-compiler zulip][z]
+- [The compiler's documentation (rustdocs)](https://doc.rust-lang.org/nightly/nightly-rustc/)
+- [The Forge](https://forge.rust-lang.org/) has more documentation about various procedures.
+- `#contribute` and `#rustdoc` on [Discord](https://discord.gg/rust-lang).
diff --git a/src/doc/rustc-dev-guide/src/git.md b/src/doc/rustc-dev-guide/src/git.md
new file mode 100644
index 000000000..f16c22d93
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/git.md
@@ -0,0 +1,435 @@
+# Using Git
+
+<!-- toc -->
+
+The Rust project uses [Git] to manage its source code. In order to
+contribute, you'll need some familiarity with its features so that your changes
+can be incorporated into the compiler.
+
+[Git]: https://git-scm.com
+
+The goal of this page is to cover some of the more common questions and
+problems new contributors face. Although some Git basics will be covered here,
+if you  find that this is still a little too fast for you, it might make sense
+to first read some introductions to Git, such as the Beginner and Getting
+started sections of [this tutorial from Atlassian][atlassian-git]. GitHub also
+provides [documentation] and [guides] for beginners, or you can consult the
+more in depth [book from Git].
+
+[book from Git]: https://git-scm.com/book/en/v2/
+[atlassian-git]: https://www.atlassian.com/git/tutorials/what-is-version-control
+[documentation]: https://docs.github.com/en/get-started/quickstart/set-up-git
+[guides]: https://guides.github.com/introduction/git-handbook/
+
+## Prerequisites
+
+We'll assume that you've installed Git, forked [rust-lang/rust], and cloned the
+forked repo to your PC. We'll use the command line interface to interact
+with Git; there are also a number of GUIs and IDE integrations that can
+generally do the same things.
+
+[rust-lang/rust]: https://github.com/rust-lang/rust
+
+If you've cloned your fork, then you will be able to reference it with `origin`
+in your local repo. It may be helpful to also set up a remote for the official
+rust-lang/rust repo via
+
+```sh
+git remote add upstream https://github.com/rust-lang/rust.git
+```
+
+if you're using HTTPS, or
+
+```sh
+git remote add upstream git@github.com:rust-lang/rust.git
+```
+
+if you're using SSH.
+
+**NOTE:** This page is dedicated to workflows for `rust-lang/rust`, but will likely be
+useful when contributing to other repositories in the Rust project.
+
+
+## Standard Process
+
+Below is the normal procedure that you're likely to use for most minor changes
+and PRs:
+
+ 1. Ensure that you're making your changes on top of master:
+ `git checkout master`.
+ 2. Get the latest changes from the Rust repo: `git pull upstream master --ff-only`.
+ (see [No-Merge Policy](#keeping-things-up-to-date) for more info about this).
+ 3. Make a new branch for your change: `git checkout -b issue-12345-fix`.
+ 4. Make some changes to the repo and test them.
+ 5. Stage your changes via `git add src/changed/file.rs src/another/change.rs`
+ and then commit them with `git commit`. Of course, making intermediate commits
+ may be a good idea as well. Avoid `git add .`, as it makes it too easy to
+ unintentionally commit changes that should not be committed, such as submodule
+ updates. You can use `git status` to check if there are any files you forgot
+ to stage.
+ 6. Push your changes to your fork: `git push --set-upstream origin issue-12345-fix`
+ (After adding commits, you can use `git push` and after rebasing or
+pulling-and-rebasing, you can use `git push --force-with-lease`).
+ 7. [Open a PR][ghpullrequest] from your fork to `rust-lang/rust`'s master branch.
+
+[ghpullrequest]: https://guides.github.com/activities/forking/#making-a-pull-request
+
+If you end up needing to rebase and are hitting conflicts, see [Rebasing](#rebasing).
+If you want to track upstream while working on long-running feature/issue, see
+[Keeping things up to date](#keeping-things-up-to-date).
+
+If your reviewer requests changes, the procedure for those changes looks much
+the same, with some steps skipped:
+
+ 1. Ensure that you're making changes to the most recent version of your code:
+ `git checkout issue-12345-fix`.
+ 2. Make, stage, and commit your additional changes just like before.
+ 3. Push those changes to your fork: `git push`.
+
+## Troubleshooting git issues
+
+You don't need to clone `rust-lang/rust` from scratch if it's out of date!
+Even if you think you've messed it up beyond repair, there are ways to fix
+the git state that don't require downloading the whole repository again.
+Here are some common issues you might run into:
+
+### I deleted my fork on GitHub!
+
+This is not a problem from git's perspective. If you run `git remote -v`,
+it will say something like this:
+
+```
+$ git remote -v
+origin	https://github.com//rust-lang/rust (fetch)
+origin	https://github.com//rust-lang/rust (push)
+personal	https://github.com/jyn514/rust (fetch)
+personal	https://github.com/jyn514/rust (push)
+```
+
+If you renamed your fork, you can change the URL like this:
+
+```console
+git remote set-url personal <URL>
+```
+
+where the `<URL>` is your new fork.
+
+### I see 'Untracked Files: src/stdarch'?
+
+This is left over from the move to the `library/` directory.
+Unfortunately, `git rebase` does not follow renames for submodules, so you
+have to delete the directory yourself:
+
+```console
+rm -r src/stdarch
+```
+
+### I see `<<< HEAD`?
+
+You were probably in the middle of a rebase or merge conflict. See
+[Conflicts](#conflicts) for how to fix the conflict. If you don't care about the changes
+and just want to get a clean copy of the repository back, you can use `git reset`:
+
+```console
+# WARNING: this throws out any local changes you've made! Consider resolving the conflicts instead.
+git reset --hard master
+```
+
+### Quick note about submodules
+
+When updating your local repository with `git pull`, you may notice that sometimes
+Git says you have modified some files that you have never edited. For example,
+running `git status` gives you something like (note the `new commits` mention):
+
+```
+On branch master
+Your branch is up to date with 'origin/master'.
+
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git restore <file>..." to discard changes in working directory)
+	modified:   src/tools/cargo (new commits)
+	modified:   src/tools/rls (new commits)
+
+no changes added to commit (use "git add" and/or "git commit -a")
+```
+
+These changes are not changes to files: they are changes to submodules (more on
+this [later](#git-submodules)). To get rid of those, run `git submodule update`
+(or run any `x.py` command, which will automatically update the submodules).
+Note that there is (as of <!-- date: 2022-02 --> February 2022) a [bug][#77620] if you use
+worktrees, submodules, and `x.py` in a commit hook. If you run into an error
+like:
+
+```
+error: failed to read `/home/joshua/rustc-worktree/src/tools/miri/cargo-miri/Cargo.toml`
+
+Caused by:
+  No such file or directory (os error 2)
+```
+it's not anything you did wrong. There is a workaround in [the issue][#77620-workaround].
+
+[#77620]: https://github.com/rust-lang/rust/issues/77620
+[#77620-workaround]: https://github.com/rust-lang/rust/issues/77620#issuecomment-705228229
+
+## Rebasing and Conflicts
+
+When you edit your code locally, you are making changes to the version of
+rust-lang/rust that existed when you created your feature branch. As such, when
+you submit your PR it is possible that some of the changes that have been made
+to rust-lang/rust since then are in conflict with the changes you've made.
+
+When this happens, you need to resolve the conflicts before your changes can be
+merged. First, get a local copy of the conflicting changes: Checkout your local
+master branch with `git checkout master`, then `git pull upstream master` to
+update it with the most recent changes.
+
+### Rebasing
+
+You're now ready to start the rebasing process. Checkout the branch with your
+changes and execute `git rebase master`.
+
+When you rebase a branch on master, all the changes on your branch are
+reapplied to the most recent version of master. In other words, Git tries to
+pretend that the changes you made to the old version of master were instead
+made to the new version of master. During this process, you should expect to
+encounter at least one "rebase conflict." This happens when Git's attempt to
+reapply the changes fails because your changes conflicted with other changes
+that have been made. You can tell that this happened because you'll see
+lines in the output that look like
+
+```
+CONFLICT (content): Merge conflict in file.rs
+```
+
+When you open these files, you'll see sections of the form
+
+```
+<<<<<<< HEAD
+Original code
+=======
+Your code
+>>>>>>> 8fbf656... Commit fixes 12345
+```
+
+This represents the lines in the file that Git could not figure out how to
+rebase. The section between `<<<<<<< HEAD` and `=======` has the code from
+master, while the other side has your version of the code. You'll need to
+decide how to deal with the conflict. You may want to keep your changes,
+keep the changes on master, or combine the two.
+
+Generally, resolving the conflict consists of two steps: First, fix the
+particular conflict. Edit the file to make the changes you want and remove the
+`<<<<<<<`, `=======` and `>>>>>>>` lines in the process. Second, check the
+surrounding code. If there was a conflict, its likely there are some logical
+errors lying around too! It's a good idea to run `x.py check` here to make sure
+there are no glaring errors.
+
+Once you're all done fixing the conflicts, you need to stage the files that had
+conflicts in them via `git add`. Afterwards, run `git rebase --continue` to let
+Git know that you've resolved the conflicts and it should finish the rebase.
+
+Once the rebase has succeeded, you'll want to update the associated branch on
+your fork with `git push --force-with-lease`.
+
+Note that `git push` will not work properly and say something like this:
+
+```
+ ! [rejected]        issue-xxxxx -> issue-xxxxx (non-fast-forward)
+error: failed to push some refs to 'https://github.com/username/rust.git'
+hint: Updates were rejected because the tip of your current branch is behind
+hint: its remote counterpart. Integrate the remote changes (e.g.
+hint: 'git pull ...') before pushing again.
+hint: See the 'Note about fast-forwards' in 'git push --help' for details.
+```
+
+The advice this gives is incorrect! Because of Rust's
+["no-merge" policy](#no-merge-policy) the merge commit created by `git pull`
+will not be allowed in the final PR, in addition to defeating the point of the
+rebase! Use `git push --force-with-lease` instead.
+
+### Keeping things up to date
+
+The above section on [Rebasing](#rebasing) is a specific
+guide on rebasing work and dealing with merge conflicts.
+Here is some general advice about how to keep your local repo
+up-to-date with upstream changes:
+
+Using `git pull upstream master` while on your local master branch regularly
+will keep it up-to-date. You will also want to rebase your feature branches
+up-to-date as well. After pulling, you can checkout the feature branches
+and rebase them:
+
+```
+git checkout master
+git pull upstream master --ff-only # to make certain there are no merge commits
+git checkout feature_branch
+git rebase master
+git push --force-with-lease (set origin to be the same as local)
+```
+
+To avoid merges as per the [No-Merge Policy](#no-merge-policy), you may want to use
+`git config pull.ff only` (this will apply the config only to the local repo)
+to ensure that Git doesn't create merge commits when `git pull`ing, without
+needing to pass `--ff-only` or `--rebase` every time.
+
+You can also `git push --force-with-lease` from master to keep your origin's master in sync with
+upstream.
+
+## Advanced Rebasing
+
+If your branch contains multiple consecutive rewrites of the same code, or if
+the rebase conflicts are extremely severe, you can use
+`git rebase --interactive master` to gain more control over the process. This
+allows you to choose to skip commits, edit the commits that you do not skip,
+change the order in which they are applied, or "squash" them into each other.
+
+Alternatively, you can sacrifice the commit history like this:
+
+```
+# squash all the changes into one commit so you only have to worry about conflicts once
+git rebase -i $(git merge-base master HEAD)  # and squash all changes along the way
+git rebase master
+# fix all merge conflicts
+git rebase --continue
+```
+
+"Squashing" commits into each other causes them to be merged into a single
+commit. Both the upside and downside of this is that it simplifies the history.
+On the one hand, you lose track of the steps in which changes were made, but
+the history becomes easier to work with.
+
+You also may want to squash just the last few commits together, possibly
+because they only represent "fixups" and not real changes. For example,
+`git rebase --interactive HEAD~2` will allow you to edit the two commits only.
+
+### `git range-diff`
+
+After completing a rebase, and before pushing up your changes, you may want to
+review the changes between your old branch and your new one. You can do that
+with `git range-diff master @{upstream} HEAD`.
+
+The first argument to `range-diff`, `master` in this case, is the base revision
+that you're comparing your old and new branch against. The second argument is
+the old version of your branch; in this case, `@upstream` means the version that
+you've pushed to GitHub, which is the same as what people will see in your pull
+request. Finally, the third argument to `range-diff` is the *new* version of
+your branch; in this case, it is `HEAD`, which is the commit that is currently
+checked-out in your local repo.
+
+Note that you can also use the equivalent, abbreviated form `git range-diff
+master @{u} HEAD`.
+
+Unlike in regular Git diffs, you'll see a `-` or `+` next to another `-` or `+`
+in the range-diff output. The marker on the left indicates a change between the
+old branch and the new branch, and the marker on the right indicates a change
+you've committed. So, you can think of a range-diff as a "diff of diffs" since
+it shows you the differences between your old diff and your new diff.
+
+Here's an example of `git range-diff` output (taken from [Git's
+docs][range-diff-example-docs]):
+
+```
+-:  ------- > 1:  0ddba11 Prepare for the inevitable!
+1:  c0debee = 2:  cab005e Add a helpful message at the start
+2:  f00dbal ! 3:  decafe1 Describe a bug
+    @@ -1,3 +1,3 @@
+     Author: A U Thor <author@example.com>
+
+    -TODO: Describe a bug
+    +Describe a bug
+    @@ -324,5 +324,6
+      This is expected.
+
+    -+What is unexpected is that it will also crash.
+    ++Unexpectedly, it also crashes. This is a bug, and the jury is
+    ++still out there how to fix it best. See ticket #314 for details.
+
+      Contact
+3:  bedead < -:  ------- TO-UNDO
+```
+
+(Note that `git range-diff` output in your terminal will probably be easier to
+read than in this example because it will have colors.)
+
+Another feature of `git range-diff` is that, unlike `git diff`, it will also
+diff commit messages. This feature can be useful when amending several commit
+messages so you can make sure you changed the right parts.
+
+`git range-diff` is a very useful command, but note that it can take some time
+to get used to its output format. You may also find Git's documentation on the
+command useful, especially their ["Examples" section][range-diff-example-docs].
+
+[range-diff-example-docs]: https://git-scm.com/docs/git-range-diff#_examples
+
+## No-Merge Policy
+
+The rust-lang/rust repo uses what is known as a "rebase workflow." This means
+that merge commits in PRs are not accepted. As a result, if you are running
+`git merge` locally, chances are good that you should be rebasing instead. Of
+course, this is not always true; if your merge will just be a fast-forward,
+like the merges that `git pull` usually performs, then no merge commit is
+created and you have nothing to worry about. Running `git config merge.ff only`
+(this will apply the config to the local repo).
+once will ensure that all the merges you perform are of this type, so that you
+cannot make a mistake.
+
+There are a number of reasons for this decision and like all others, it is a
+tradeoff. The main advantage is the generally linear commit history. This
+greatly simplifies bisecting and makes the history and commit log much easier
+to follow and understand.
+
+## Git submodules
+
+**NOTE**: submodules are a nice thing to know about, but it *isn't* an absolute
+prerequisite to contribute to `rustc`. If you are using Git for the first time,
+you might want to get used to the main concepts of Git before reading this section.
+
+The `rust-lang/rust` repository uses [Git submodules] as a way to use other
+Rust projects from within the `rust` repo. Examples include Rust's fork of
+`llvm-project` and many devtools such as `cargo` and `rls`.
+
+Those projects are developed and maintained in an separate Git (and GitHub)
+repository, and they have their own Git history/commits, issue tracker and PRs.
+Submodules allow us to create some sort of embedded sub-repository inside the
+`rust` repository and use them like they were directories in the `rust` repository.
+
+Take `miri` for example. `miri` is maintained in the [`rust-lang/miri`] repository,
+but it is used in `rust-lang/rust` by the compiler for const evaluation. We bring it
+in `rust` as a submodule, in the `src/tools/miri` folder.
+
+The contents of submodules are ignored by Git: submodules are in some sense isolated
+from the rest of the repository. However, if you try to `cd src/tools/miri` and then
+run `git status`:
+
+```
+HEAD detached at 3fafb835
+nothing to commit, working tree clean
+```
+
+As far as git is concerned, you are no longer in the `rust` repo, but in the `miri` repo.
+You will notice that we are in "detached HEAD" state, i.e. not on a branch but on a
+particular commit.
+
+This is because, like any dependency, we want to be able to control which version to use.
+Submodules allow us to do just that: every submodule is "pinned" to a certain
+commit, which doesn't change unless modified manually. If you use `git checkout <commit>`
+in the `miri` directory and go back to the `rust` directory, you can stage this
+change like any other, e.g. by running `git add src/tools/miri`. (Note that if
+you *don't* stage the change to commit, then you run the risk that running
+`x.py` will just undo your change by switching back to the previous commit when
+it automatically "updates" the submodules.)
+
+This version selection is usually done by the maintainers of the project, and
+looks like [this][miri-update].
+
+Git submodules take some time to get used to, so don't worry if it isn't perfectly
+clear yet. You will rarely have to use them directly and, again, you don't need
+to know everything about submodules to contribute to Rust. Just know that they
+exist and that they correspond to some sort of embedded subrepository dependency
+that Git can nicely and fairly conveniently handle for us.
+
+[Git submodules]: https://git-scm.com/book/en/v2/Git-Tools-Submodules
+[`rust-toolstate`]: https://rust-lang-nursery.github.io/rust-toolstate/
+[`rust-lang/miri`]: https://github.com/rust-lang/miri
+[miri-update]: https://github.com/rust-lang/rust/pull/77500/files
diff --git a/src/doc/rustc-dev-guide/src/hir-debugging.md b/src/doc/rustc-dev-guide/src/hir-debugging.md
new file mode 100644
index 000000000..8788ad4de
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/hir-debugging.md
@@ -0,0 +1,8 @@
+# HIR Debugging
+
+The `-Z unpretty=hir-tree` flag will dump out the HIR.
+
+If you are trying to correlate `NodeId`s or `DefId`s with source code, the
+`--pretty expanded,identified` flag may be useful.
+
+TODO: anything else? [#1159](https://github.com/rust-lang/rustc-dev-guide/issues/1159)
diff --git a/src/doc/rustc-dev-guide/src/hir.md b/src/doc/rustc-dev-guide/src/hir.md
new file mode 100644
index 000000000..8316f7ce3
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/hir.md
@@ -0,0 +1,136 @@
+# The HIR
+
+<!-- toc -->
+
+The HIR – "High-Level Intermediate Representation" – is the primary IR used
+in most of rustc. It is a compiler-friendly representation of the abstract
+syntax tree (AST) that is generated after parsing, macro expansion, and name
+resolution (see [Lowering](./lowering.html) for how the HIR is created).
+Many parts of HIR resemble Rust surface syntax quite closely, with
+the exception that some of Rust's expression forms have been desugared away.
+For example, `for` loops are converted into a `loop` and do not appear in
+the HIR. This makes HIR more amenable to analysis than a normal AST.
+
+This chapter covers the main concepts of the HIR.
+
+You can view the HIR representation of your code by passing the
+`-Z unpretty=hir-tree` flag to rustc:
+
+```bash
+cargo rustc -- -Z unpretty=hir-tree
+```
+
+## Out-of-band storage and the `Crate` type
+
+The top-level data-structure in the HIR is the [`Crate`], which stores
+the contents of the crate currently being compiled (we only ever
+construct HIR for the current crate). Whereas in the AST the crate
+data structure basically just contains the root module, the HIR
+`Crate` structure contains a number of maps and other things that
+serve to organize the content of the crate for easier access.
+
+[`Crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Crate.html
+
+For example, the contents of individual items (e.g. modules,
+functions, traits, impls, etc) in the HIR are not immediately
+accessible in the parents. So, for example, if there is a module item
+`foo` containing a function `bar()`:
+
+```rust
+mod foo {
+    fn bar() { }
+}
+```
+
+then in the HIR the representation of module `foo` (the [`Mod`]
+struct) would only have the **`ItemId`** `I` of `bar()`. To get the
+details of the function `bar()`, we would lookup `I` in the
+`items` map.
+
+[`Mod`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Mod.html
+
+One nice result from this representation is that one can iterate
+over all items in the crate by iterating over the key-value pairs
+in these maps (without the need to trawl through the whole HIR).
+There are similar maps for things like trait items and impl items,
+as well as "bodies" (explained below).
+
+The other reason to set up the representation this way is for better
+integration with incremental compilation. This way, if you gain access
+to an [`&rustc_hir::Item`] (e.g. for the mod `foo`), you do not immediately
+gain access to the contents of the function `bar()`. Instead, you only
+gain access to the **id** for `bar()`, and you must invoke some
+function to lookup the contents of `bar()` given its id; this gives
+the compiler a chance to observe that you accessed the data for
+`bar()`, and then record the dependency.
+
+[`&rustc_hir::Item`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Item.html
+
+<a name="hir-id"></a>
+
+## Identifiers in the HIR
+
+There are a bunch of different identifiers to refer to other nodes or definitions
+in the HIR. In short:
+- A [`DefId`] refers to a *definition* in any crate.
+- A [`LocalDefId`] refers to a *definition* in the currently compiled crate.
+- A [`HirId`] refers to *any node* in the HIR.
+
+For more detailed information, check out the [chapter on identifiers][ids].
+
+[`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html
+[`LocalDefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.LocalDefId.html
+[`HirId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir_id/struct.HirId.html
+[ids]: ./identifiers.md#in-the-hir
+
+## The HIR Map
+
+Most of the time when you are working with the HIR, you will do so via
+the **HIR Map**, accessible in the tcx via [`tcx.hir()`] (and defined in
+the [`hir::map`] module). The [HIR map] contains a [number of methods] to
+convert between IDs of various kinds and to lookup data associated
+with a HIR node.
+
+[`tcx.hir()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.hir
+[`hir::map`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/index.html
+[HIR map]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html
+[number of methods]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#methods
+
+For example, if you have a [`LocalDefId`], and you would like to convert it
+to a [`HirId`], you can use [`tcx.hir().local_def_id_to_hir_id(def_id)`][local_def_id_to_hir_id].
+You need a `LocalDefId`, rather than a `DefId`, since only local items have HIR nodes.
+
+[local_def_id_to_hir_id]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.local_def_id_to_hir_id
+
+Similarly, you can use [`tcx.hir().find(n)`][find] to lookup the node for a
+[`HirId`]. This returns a `Option<Node<'hir>>`, where [`Node`] is an enum
+defined in the map. By matching on this, you can find out what sort of
+node the `HirId` referred to and also get a pointer to the data
+itself. Often, you know what sort of node `n` is – e.g. if you know
+that `n` must be some HIR expression, you can do
+[`tcx.hir().expect_expr(n)`][expect_expr], which will extract and return the
+[`&hir::Expr`][Expr], panicking if `n` is not in fact an expression.
+
+[find]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.find
+[`Node`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/enum.Node.html
+[expect_expr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.expect_expr
+[Expr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Expr.html
+
+Finally, you can use the HIR map to find the parents of nodes, via
+calls like [`tcx.hir().get_parent_node(n)`][get_parent_node].
+
+[get_parent_node]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.get_parent_node
+
+## HIR Bodies
+
+A [`rustc_hir::Body`] represents some kind of executable code, such as the body
+of a function/closure or the definition of a constant. Bodies are
+associated with an **owner**, which is typically some kind of item
+(e.g. an `fn()` or `const`), but could also be a closure expression
+(e.g. `|x, y| x + y`). You can use the HIR map to find the body
+associated with a given def-id ([`maybe_body_owned_by`]) or to find
+the owner of a body ([`body_owner_def_id`]).
+
+[`rustc_hir::Body`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Body.html
+[`maybe_body_owned_by`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.maybe_body_owned_by
+[`body_owner_def_id`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.body_owner_def_id
diff --git a/src/doc/rustc-dev-guide/src/identifiers.md b/src/doc/rustc-dev-guide/src/identifiers.md
new file mode 100644
index 000000000..18a3efefc
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/identifiers.md
@@ -0,0 +1,108 @@
+# Identifiers in the Compiler
+
+If you have read the few previous chapters, you now know that `rustc` uses
+many different intermediate representations to perform different kinds of analyses.
+However, like in every data structure, you need a way to traverse the structure
+and refer to other elements. In this chapter, you will find information on the
+different identifiers `rustc` uses for each intermediate representation.
+
+## In the AST
+
+A [`NodeId`] is an identifier number that uniquely identifies an AST node within
+a crate. Every node in the AST has its own [`NodeId`], including top-level items
+such as structs, but also individual statements and expressions.
+
+However, because they are absolute within a crate, adding or removing a single
+node in the AST causes all the subsequent [`NodeId`]s to change. This renders
+[`NodeId`]s pretty much useless for incremental compilation, where you want as
+few things as possible to change.
+
+[`NodeId`]s are used in all the `rustc` bits that operate directly on the AST,
+like macro expansion and name resolution.
+
+[`NodeId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html
+
+## In the HIR
+
+The HIR uses a bunch of different identifiers that coexist and serve different purposes.
+
+- A [`DefId`], as the name suggests, identifies a particular definition, or top-level
+  item, in a given crate. It is composed of two parts: a [`CrateNum`] which identifies
+  the crate the definition comes from, and a [`DefIndex`] which identifies the definition
+  within the crate. Unlike [`HirId`]s, there isn't a [`DefId`] for every expression, which
+  makes them more stable across compilations.
+
+- A [`LocalDefId`] is basically a [`DefId`] that is known to come from the current crate.
+  This allows us to drop the [`CrateNum`] part, and use the type system to ensure that
+  only local definitions are passed to functions that expect a local definition.
+
+- A [`HirId`] uniquely identifies a node in the HIR of the current crate. It is composed
+  of two parts: an `owner` and a `local_id` that is unique within the `owner`. This
+  combination makes for more stable values which are helpful for incremental compilation.
+  Unlike [`DefId`]s, a [`HirId`] can refer to [fine-grained entities][Node] like expressions,
+  but stays local to the current crate.
+
+- A [`BodyId`] identifies a HIR [`Body`] in the current crate. It is currently only
+  a wrapper around a [`HirId`]. For more info about HIR bodies, please refer to the
+  [HIR chapter][hir-bodies].
+
+These identifiers can be converted into one another through the [HIR map][map].
+See the [HIR chapter][hir-map] for more detailed information.
+
+[`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html
+[`LocalDefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.LocalDefId.html
+[`HirId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir_id/struct.HirId.html
+[`BodyId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.BodyId.html
+[`CrateNum`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.CrateNum.html
+[`DefIndex`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefIndex.html
+[`Body`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Body.html
+[Node]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.Node.html
+[hir-map]: ./hir.md#the-hir-map
+[hir-bodies]: ./hir.md#hir-bodies
+[map]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html
+
+## In the MIR
+
+- [`BasicBlock`] identifies a *basic block*. It points to an instance of
+  [`BasicBlockData`], which can be retrieved by indexing into
+  [`Body::basic_blocks()`] (note that you must call a function; the field is
+  private).
+
+- [`Local`] identifies a local variable in a function. Its associated data is in
+  [`LocalDecl`], which can be retrieved by indexing into [`Body.local_decls`].
+
+- [`Field`] identifies a struct's, union's, or enum variant's field. It is used
+  as a "projection" in [`Place`].
+
+- [`SourceScope`] identifies a name scope in the original source code. Used for
+  diagnostics and for debuginfo in debuggers. It points to an instance of
+  [`SourceScopeData`], which can be retrieved by indexing into
+  [`Body.source_scopes`].
+
+- [`Promoted`] identifies a promoted constant within another item (related to
+  const evaluation). Note: it is unique only locally within the item, so it
+  should be associated with a `DefId`.
+  [`GlobalId`] will give you a more specific identifier.
+
+- [`GlobalId`] identifies a global variable: a `const`, a `static`, a `const fn`
+  where all arguments are [zero-sized types], or a promoted constant.
+
+- [`Location`] represents the location in the MIR of a statement or terminator.
+  It identifies the block (using [`BasicBlock`]) and the index of the statement
+  or terminator in the block.
+
+[`BasicBlock`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlock.html
+[`BasicBlockData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlockData.html
+[`Body::basic_blocks()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#method.basic_blocks
+[`Local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Local.html
+[`LocalDecl`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.LocalDecl.html
+[`Body.local_decls`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.local_decls
+[`Field`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Field.html
+[`Place`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Place.html
+[`SourceScope`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.SourceScope.html
+[`SourceScopeData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.SourceScopeData.html
+[`Body.source_scopes`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.source_scopes
+[`Promoted`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Promoted.html
+[`GlobalId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/struct.GlobalId.html
+[`Location`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Location.html
+[zero-sized types]: https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts
diff --git a/src/doc/rustc-dev-guide/src/img/coverage-branch-counting-01.png b/src/doc/rustc-dev-guide/src/img/coverage-branch-counting-01.png
new file mode 100644
index 000000000..c445f3552
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/coverage-branch-counting-01.png
diff --git a/src/doc/rustc-dev-guide/src/img/coverage-graphviz-01.png b/src/doc/rustc-dev-guide/src/img/coverage-graphviz-01.png
new file mode 100644
index 000000000..cf7e1e76b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/coverage-graphviz-01.png
diff --git a/src/doc/rustc-dev-guide/src/img/coverage-spanview-01.png b/src/doc/rustc-dev-guide/src/img/coverage-spanview-01.png
new file mode 100644
index 000000000..f3e4b3535
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/coverage-spanview-01.png
diff --git a/src/doc/rustc-dev-guide/src/img/dataflow-graphviz-example.png b/src/doc/rustc-dev-guide/src/img/dataflow-graphviz-example.png
new file mode 100644
index 000000000..718411a8c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/dataflow-graphviz-example.png
diff --git a/src/doc/rustc-dev-guide/src/img/llvm-cov-show-01.png b/src/doc/rustc-dev-guide/src/img/llvm-cov-show-01.png
new file mode 100644
index 000000000..35f045943
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/llvm-cov-show-01.png
diff --git a/src/doc/rustc-dev-guide/src/img/rustc_stages.svg b/src/doc/rustc-dev-guide/src/img/rustc_stages.svg
new file mode 100644
index 000000000..25f7ab11b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/rustc_stages.svg
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" style="background-color: rgb(255, 255, 255);" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="581px" height="816px" viewBox="-0.5 -0.5 581 816"><defs/><g><rect x="0" y="0" width="580" height="315" fill="#ffffff" stroke="#000000" pointer-events="all"/><rect x="0" y="665" width="580" height="150" fill="#ffffff" stroke="#000000" pointer-events="all"/><rect x="0" y="345" width="580" height="287.5" fill="#ffffff" stroke="#000000" pointer-events="all"/><path d="M 120 25 L 193.63 25" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 198.88 25 L 191.88 28.5 L 193.63 25 L 191.88 21.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 25px; margin-left: 160px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Download</div></div></div></foreignObject><text x="160" y="28" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Download</text></switch></g><rect x="40" y="10" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 25px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">beta</div></div></div></foreignObject><text x="80" y="29" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">beta</text></switch></g><rect x="200" y="10" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 25px; margin-left: 201px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0</div></div></div></foreignObject><text x="240" y="29" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0</text></switch></g><path d="M 120 120 L 173.63 120" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 120 L 171.88 123.5 L 173.63 120 L 171.88 116.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 120px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="123" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="105" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 120px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0</div></div></div></foreignObject><text x="80" y="124" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0</text></switch></g><path d="M 260 120 L 313.63 120" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 120 L 311.88 123.5 L 313.63 120 L 311.88 116.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 120px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="123" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="105" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 120px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">libtest/libstd</div></div></div></foreignObject><text x="220" y="124" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">libtest/libstd</text></switch></g><path d="M 400 120 L 453.63 120" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 458.88 120 L 451.88 123.5 L 453.63 120 L 451.88 116.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 120px; margin-left: 430px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="430" y="123" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="320" y="105" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 120px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-std</div></div></div></foreignObject><text x="360" y="124" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-std</text></switch></g><path d="M 515 135 L 515 145 Q 515 155 505 155 L 230 155 Q 220 155 220 161.82 L 220 168.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 173.88 L 216.5 166.88 L 220 168.63 L 223.5 166.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="460" y="105" width="110" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 120px; margin-left: 461px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-sysroot</div></div></div></foreignObject><text x="515" y="124" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-sysroot</text></switch></g><path d="M 120 190 L 173.63 190" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 190 L 171.88 193.5 L 173.63 190 L 171.88 186.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 190px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="193" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="175" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 190px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0</div></div></div></foreignObject><text x="80" y="194" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0</text></switch></g><path d="M 260 190 L 313.63 190" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 190 L 311.88 193.5 L 313.63 190 L 311.88 186.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 190px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="193" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="175" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 190px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">rustc</div></div></div></foreignObject><text x="220" y="194" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">rustc</text></switch></g><path d="M 400 190 L 453.63 190" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 458.88 190 L 451.88 193.5 L 453.63 190 L 451.88 186.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 190px; margin-left: 430px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="430" y="193" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="320" y="175" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 190px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-rustc</div></div></div></foreignObject><text x="360" y="194" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-rustc</text></switch></g><path d="M 515 205 L 515 227.5 Q 515 237.5 505 237.5 L 230 237.5 Q 220 237.5 220 247.5 L 220 263.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 268.88 L 216.5 261.88 L 220 263.63 L 223.5 261.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="460" y="175" width="110" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 190px; margin-left: 461px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-sysroot</div></div></div></foreignObject><text x="515" y="194" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-sysroot</text></switch></g><path d="M 120 237.5 L 210 237.5 Q 220 237.5 220 247.5 L 220 263.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 268.88 L 216.5 261.88 L 220 263.63 L 223.5 261.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="40" y="222.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 238px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">llvm</div></div></div></foreignObject><text x="80" y="241" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">llvm</text></switch></g><path d="M 120 285 L 173.63 285" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 285 L 171.88 288.5 L 173.63 285 L 171.88 281.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 285px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="288" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="270" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 285px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0</div></div></div></foreignObject><text x="80" y="289" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0</text></switch></g><path d="M 260 285 L 313.63 285" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 285 L 311.88 288.5 L 313.63 285 L 311.88 281.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 285px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="288" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="270" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 285px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">codegen</div></div></div></foreignObject><text x="220" y="289" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">codegen</text></switch></g><rect x="320" y="270" width="100" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 285px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-codegen</div></div></div></foreignObject><text x="370" y="289" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-codegen</text></switch></g><rect x="-30" y="145" width="90" height="20" fill="none" stroke="none" transform="rotate(-90,15,155)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-90 15 155)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 155px; margin-left: -29px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 24px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Stage 0</div></div></div></foreignObject><text x="15" y="162" fill="#000000" font-family="Helvetica" font-size="24px" text-anchor="middle">Stage 0</text></switch></g><path d="M 150 380 L 203.63 380" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 208.88 380 L 201.88 383.5 L 203.63 380 L 201.88 376.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 380px; margin-left: 174px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="174" y="383" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="40" y="355" width="110" height="50" rx="7.5" ry="7.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 380px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0-rustc<br />stage0-codegen<br />stage0-sysroot</div></div></div></foreignObject><text x="95" y="384" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0-rustc...</text></switch></g><path d="M 250 395 L 250 405 Q 250 415 240 415 L 90 415 Q 80 415 80 421.82 L 80 428.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 80 433.88 L 76.5 426.88 L 80 428.63 L 83.5 426.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="210" y="365" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 380px; margin-left: 211px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1</div></div></div></foreignObject><text x="250" y="384" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1</text></switch></g><path d="M 120 450 L 173.63 450" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 450 L 171.88 453.5 L 173.63 450 L 171.88 446.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 450px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="453" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="435" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 450px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1</div></div></div></foreignObject><text x="80" y="454" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1</text></switch></g><path d="M 260 450 L 313.63 450" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 450 L 311.88 453.5 L 313.63 450 L 311.88 446.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 450px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="453" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="435" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 450px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">libtest/libstd</div></div></div></foreignObject><text x="220" y="454" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">libtest/libstd</text></switch></g><path d="M 400 450 L 453.63 450" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 458.88 450 L 451.88 453.5 L 453.63 450 L 451.88 446.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 450px; margin-left: 430px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="430" y="453" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="320" y="435" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 450px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1-std</div></div></div></foreignObject><text x="360" y="454" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1-std</text></switch></g><path d="M 515 465 L 515 477.5 Q 515 487.5 505 487.5 L 230 487.5 Q 220 487.5 220 495.57 L 220 503.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 508.88 L 216.5 501.88 L 220 503.63 L 223.5 501.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="460" y="435" width="110" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 450px; margin-left: 461px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1/lib/rustlib</div></div></div></foreignObject><text x="515" y="454" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1/lib/rustlib</text></switch></g><path d="M 120 525 L 173.63 525" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 525 L 171.88 528.5 L 173.63 525 L 171.88 521.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 525px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="528" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="510" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 525px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1</div></div></div></foreignObject><text x="80" y="529" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1</text></switch></g><path d="M 260 525 L 313.63 525" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 525 L 311.88 528.5 L 313.63 525 L 311.88 521.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 525px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="528" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="510" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 525px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">rustc</div></div></div></foreignObject><text x="220" y="529" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">rustc</text></switch></g><path d="M 400 525 L 453.63 525" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 458.88 525 L 451.88 528.5 L 453.63 525 L 451.88 521.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 525px; margin-left: 430px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="430" y="528" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="320" y="510" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 525px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1-rustc</div></div></div></foreignObject><text x="360" y="529" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1-rustc</text></switch></g><path d="M 515 540 L 515 550 Q 515 560 505 560 L 230 560 Q 220 560 220 566.82 L 220 573.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 578.88 L 216.5 571.88 L 220 573.63 L 223.5 571.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="460" y="510" width="110" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 525px; margin-left: 461px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1/lib/rustlib</div></div></div></foreignObject><text x="515" y="529" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1/lib/rustlib</text></switch></g><path d="M 120 595 L 173.63 595" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 595 L 171.88 598.5 L 173.63 595 L 171.88 591.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 595px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="598" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="580" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 595px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1</div></div></div></foreignObject><text x="80" y="599" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1</text></switch></g><path d="M 260 595 L 313.63 595" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 595 L 311.88 598.5 L 313.63 595 L 311.88 591.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 595px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="598" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="580" width="80" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 595px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">codegen</div></div></div></foreignObject><text x="220" y="599" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">codegen</text></switch></g><rect x="320" y="580" width="100" height="30" rx="4.5" ry="4.5" fill="#fff2cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 595px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1-codegen</div></div></div></foreignObject><text x="370" y="599" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1-codegen</text></switch></g><rect x="-30" y="510" width="90" height="20" fill="none" stroke="none" transform="rotate(-90,15,520)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-90 15 520)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 520px; margin-left: -29px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 24px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>Stage 1</div></div></div></div></foreignObject><text x="15" y="527" fill="#000000" font-family="Helvetica" font-size="24px" text-anchor="middle">Stage 1</text></switch></g><path d="M 150 702.5 L 203.63 702.5" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 208.88 702.5 L 201.88 706 L 203.63 702.5 L 201.88 699 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 703px; margin-left: 174px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Copy</div></div></div></foreignObject><text x="174" y="706" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="40" y="677.5" width="110" height="50" rx="7.5" ry="7.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 703px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage1-rustc<br />stage1-codegen<br />stage1/lib/rustlib</div></div></div></foreignObject><text x="95" y="706" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage1-rustc...</text></switch></g><path d="M 250 717.5 L 250 730 Q 250 740 240 740 L 90 740 Q 80 740 80 748.07 L 80 756.13" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 80 761.38 L 76.5 754.38 L 80 756.13 L 83.5 754.38 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="210" y="687.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 703px; margin-left: 211px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage2</div></div></div></foreignObject><text x="250" y="706" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage2</text></switch></g><path d="M 120 777.5 L 173.63 777.5" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 777.5 L 171.88 781 L 173.63 777.5 L 171.88 774 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 778px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="781" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="762.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 778px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage2</div></div></div></foreignObject><text x="80" y="781" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage2</text></switch></g><path d="M 260 777.5 L 313.63 777.5" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 318.88 777.5 L 311.88 781 L 313.63 777.5 L 311.88 774 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 778px; margin-left: 290px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Outputs</div></div></div></foreignObject><text x="290" y="781" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Outputs</text></switch></g><rect x="180" y="762.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 778px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">rustdoc</div></div></div></foreignObject><text x="220" y="781" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">rustdoc</text></switch></g><path d="M 400 777.5 L 443.63 777.5" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 448.88 777.5 L 441.88 781 L 443.63 777.5 L 441.88 774 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 778px; margin-left: 425px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; "><div style="font-size: 11px">Copy</div></div></div></div></foreignObject><text x="425" y="781" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Copy</text></switch></g><rect x="320" y="762.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 778px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage2-tools</div></div></div></foreignObject><text x="360" y="781" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage2-tools</text></switch></g><path d="M 120 70 L 173.63 70" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 178.88 70 L 171.88 73.5 L 173.63 70 L 171.88 66.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 70px; margin-left: 144px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">Builds</div></div></div></foreignObject><text x="144" y="73" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">Builds</text></switch></g><rect x="40" y="55" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 70px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage0</div></div></div></foreignObject><text x="80" y="74" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage0</text></switch></g><rect x="180" y="55" width="80" height="30" rx="4.5" ry="4.5" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 70px; margin-left: 181px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">bootstrap</div></div></div></foreignObject><text x="220" y="74" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">bootstrap</text></switch></g><path d="M 190 560 L 130 560 Q 120 560 120 558.75 L 120 558.13 Q 120 557.5 130 557.5 L 210 557.5 Q 220 557.5 220 564.32 L 220 571.13" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 220 576.38 L 216.5 569.38 L 220 571.13 L 223.5 569.38 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="110" y="551" width="80" height="18" rx="2.7" ry="2.7" fill="#ffe6cc" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 560px; margin-left: 111px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">llvm</div></div></div></foreignObject><text x="150" y="564" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">llvm</text></switch></g><rect x="450" y="762.5" width="80" height="30" rx="4.5" ry="4.5" fill="#ccff99" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 778px; margin-left: 451px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stage2</div></div></div></foreignObject><text x="490" y="781" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stage2</text></switch></g><rect x="-30" y="735" width="90" height="20" fill="none" stroke="none" transform="rotate(-90,15,745)" pointer-events="all"/><g transform="translate(-0.5 -0.5)rotate(-90 15 745)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 745px; margin-left: -29px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 24px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>Stage 2</div></div></div></div></foreignObject><text x="15" y="752" fill="#000000" font-family="Helvetica" font-size="24px" text-anchor="middle">Stage 2</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://desk.draw.io/support/solutions/articles/16000042487" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Viewer does not support full SVG 1.1</text></a></switch></svg>
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/img/wpa-initial-memory.png b/src/doc/rustc-dev-guide/src/img/wpa-initial-memory.png
new file mode 100644
index 000000000..b6020667e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/wpa-initial-memory.png
diff --git a/src/doc/rustc-dev-guide/src/img/wpa-stack.png b/src/doc/rustc-dev-guide/src/img/wpa-stack.png
new file mode 100644
index 000000000..29eb5a54b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/img/wpa-stack.png
diff --git a/src/doc/rustc-dev-guide/src/implementing_new_features.md b/src/doc/rustc-dev-guide/src/implementing_new_features.md
new file mode 100644
index 000000000..ef6ae6179
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/implementing_new_features.md
@@ -0,0 +1,168 @@
+# Implementing new features
+
+When you want to implement a new significant feature in the compiler,
+you need to go through this process to make sure everything goes
+smoothly.
+
+## The @rfcbot FCP process
+
+When the change is small and uncontroversial, then it can be done
+with just writing a PR and getting an r+ from someone who knows that
+part of the code. However, if the change is potentially controversial,
+it would be a bad idea to push it without consensus from the rest
+of the team (both in the "distributed system" sense to make sure
+you don't break anything you don't know about, and in the social
+sense to avoid PR fights).
+
+If such a change seems to be too small to require a full formal RFC process
+(e.g., a small standard library addition, a big refactoring of the code, a
+"technically-breaking" change, or a "big bugfix" that basically amounts to a
+small feature) but is still too controversial or big to get by with a single r+,
+you can propose a final comment period (FCP). Or, if you're not on the relevant
+team (and thus don't have @rfcbot permissions), ask someone who is to start one;
+unless they have a concern themselves, they should.
+
+Again, the FCP process is only needed if you need consensus – if you
+don't think anyone would have a problem with your change, it's OK to
+get by with only an r+. For example, it is OK to add or modify
+unstable command-line flags or attributes without an FCP for
+compiler development or standard library use, as long as you don't
+expect them to be in wide use in the nightly ecosystem.
+
+You don't need to have the implementation fully ready for r+ to propose an FCP,
+but it is generally a good idea to have at least a proof
+of concept so that people can see what you are talking about.
+
+When an FCP is proposed, it requires all members of the team to sign off the
+FCP. After they all do so, there's a 10-day-long "final comment period" (hence
+the name) where everybody can comment, and if no concerns are raised, the
+PR/issue gets FCP approval.
+
+## The logistics of writing features
+
+There are a few "logistic" hoops you might need to go through in
+order to implement a feature in a working way.
+
+### Warning Cycles
+
+In some cases, a feature or bugfix might break some existing programs
+in some edge cases. In that case, you might want to do a crater run
+to assess the impact and possibly add a future-compatibility lint,
+similar to those used for
+[edition-gated lints](diagnostics.md#edition-gated-lints).
+
+### Stability
+
+We [value the stability of Rust]. Code that works and runs on stable
+should (mostly) not break. Because of that, we don't want to release
+a feature to the world with only team consensus and code review -
+we want to gain real-world experience on using that feature on nightly,
+and we might want to change the feature based on that experience.
+
+To allow for that, we must make sure users don't accidentally depend
+on that new feature - otherwise, especially if experimentation takes
+time or is delayed and the feature takes the trains to stable,
+it would end up de facto stable and we'll not be able to make changes
+in it without breaking people's code.
+
+The way we do that is that we make sure all new features are feature
+gated - they can't be used without enabling a feature gate
+(`#[feature(foo)]`), which can't be done in a stable/beta compiler.
+See the [stability in code] section for the technical details.
+
+Eventually, after we gain enough experience using the feature,
+make the necessary changes, and are satisfied, we expose it to
+the world using the stabilization process described [here].
+Until then, the feature is not set in stone: every part of the
+feature can be changed, or the feature might be completely
+rewritten or removed. Features are not supposed to gain tenure
+by being unstable and unchanged for a year.
+
+###  Tracking Issues
+
+To keep track of the status of an unstable feature, the
+experience we get while using it on nightly, and of the
+concerns that block its stabilization, every feature-gate
+needs a tracking issue.
+
+General discussions about the feature should be done on
+the tracking issue.
+
+For features that have an RFC, you should use the RFC's
+tracking issue for the feature.
+
+For other features, you'll have to make a tracking issue
+for that feature. The issue title should be "Tracking issue
+for YOUR FEATURE".
+
+For tracking issues for features (as opposed to future-compat
+warnings), I don't think the description has to contain
+anything specific. Generally we put the list of items required
+for stabilization in a checklist, e.g.,
+
+```txt
+**Steps:**
+
+- [ ] Implement the RFC. (CC @rust-lang/compiler -- can anyone write
+      up mentoring instructions?)
+- [ ] Adjust the documentation. ([See instructions on rustc-dev-guide.](stabilization_guide.md#documentation-prs))
+- [ ] Stabilize the feature. ([See instructions on rustc-dev-guide.](stabilization_guide.md#stabilization-pr))
+```
+
+##  Stability in code
+
+The below steps needs to be followed in order to implement
+a new unstable feature:
+
+1. Open a [tracking issue] -
+   if you have an RFC, you can use the tracking issue for the RFC.
+
+   The tracking issue should be labeled with at least `C-tracking-issue`.
+   For a language feature, a label `F-feature_name` should be added as well.
+
+2. Pick a name for the feature gate (for RFCs, use the name
+   in the RFC).
+
+3. Add a feature gate declaration to `rustc_feature/src/active.rs`
+   in the active `declare_features` block. See [here][add-feature-gate] for
+   detailed instructions.
+
+4. Prevent usage of the new feature unless the feature gate is set.
+   You can check it in most places in the compiler using the
+   expression `tcx.features().$feature_name` (or
+   `sess.features_untracked().$feature_name` if the
+   tcx is unavailable)
+
+    If the feature gate is not set, you should either maintain
+    the pre-feature behavior or raise an error, depending on
+    what makes sense. Errors should generally use [`rustc_session::parse::feature_err`].
+    For an example of adding an error, see [#81015].
+
+   For features introducing new syntax, pre-expansion gating should be used instead.
+   To do so, extend the [`GatedSpans`] struct, add spans to it during parsing,
+   and then finally feature-gate all the spans in
+   [`rustc_ast_passes::feature_gate::check_crate`].
+
+5. Add a test to ensure the feature cannot be used without
+   a feature gate, by creating `feature-gate-$feature_name.rs`
+   and `feature-gate-$feature_name.stderr` files under the
+   directory where the other tests for your feature reside.
+
+6. Add a section to the unstable book, in
+   `src/doc/unstable-book/src/language-features/$feature_name.md`.
+
+7. Write a lot of tests for the new feature.
+   PRs without tests will not be accepted!
+
+8. Get your PR reviewed and land it. You have now successfully
+   implemented a feature in Rust!
+
+[`GatedSpans`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/parse/struct.GatedSpans.html
+[#81015]: https://github.com/rust-lang/rust/pull/81015
+[`rustc_session::parse::feature_err`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/parse/fn.feature_err.html
+[`rustc_ast_passes::feature_gate::check_crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_passes/feature_gate/fn.check_crate.html
+[value the stability of Rust]: https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md
+[stability in code]: #stability-in-code
+[here]: ./stabilization_guide.md
+[tracking issue]: #tracking-issue
+[add-feature-gate]: ./feature-gates.md#adding-a-feature-gate
diff --git a/src/doc/rustc-dev-guide/src/incrcomp-debugging.md b/src/doc/rustc-dev-guide/src/incrcomp-debugging.md
new file mode 100644
index 000000000..ba312c959
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/incrcomp-debugging.md
@@ -0,0 +1,115 @@
+# Debugging and Testing Dependencies
+
+## Testing the dependency graph
+
+There are various ways to write tests against the dependency graph.
+The simplest mechanisms are the `#[rustc_if_this_changed]` and
+`#[rustc_then_this_would_need]` annotations. These are used in ui tests
+to test whether the expected set of paths exist in the dependency graph.
+As an example, see `src/test/ui/dep-graph/dep-graph-caller-callee.rs`.
+
+The idea is that you can annotate a test like:
+
+```rust,ignore
+#[rustc_if_this_changed]
+fn foo() { }
+
+#[rustc_then_this_would_need(TypeckTables)] //~ ERROR OK
+fn bar() { foo(); }
+
+#[rustc_then_this_would_need(TypeckTables)] //~ ERROR no path
+fn baz() { }
+```
+
+This will check whether there is a path in the dependency graph from `Hir(foo)`
+to `TypeckTables(bar)`. An error is reported for each
+`#[rustc_then_this_would_need]` annotation that indicates whether a path
+exists. `//~ ERROR` annotations can then be used to test if a path is found (as
+demonstrated above).
+
+## Debugging the dependency graph
+
+### Dumping the graph
+
+The compiler is also capable of dumping the dependency graph for your
+debugging pleasure. To do so, pass the `-Z dump-dep-graph` flag. The
+graph will be dumped to `dep_graph.{txt,dot}` in the current
+directory.  You can override the filename with the `RUST_DEP_GRAPH`
+environment variable.
+
+Frequently, though, the full dep graph is quite overwhelming and not
+particularly helpful. Therefore, the compiler also allows you to filter
+the graph. You can filter in three ways:
+
+1. All edges originating in a particular set of nodes (usually a single node).
+2. All edges reaching a particular set of nodes.
+3. All edges that lie between given start and end nodes.
+
+To filter, use the `RUST_DEP_GRAPH_FILTER` environment variable, which should
+look like one of the following:
+
+```text
+source_filter     // nodes originating from source_filter
+-> target_filter  // nodes that can reach target_filter
+source_filter -> target_filter // nodes in between source_filter and target_filter
+```
+
+`source_filter` and `target_filter` are a `&`-separated list of strings.
+A node is considered to match a filter if all of those strings appear in its
+label. So, for example:
+
+```text
+RUST_DEP_GRAPH_FILTER='-> TypeckTables'
+```
+
+would select the predecessors of all `TypeckTables` nodes. Usually though you
+want the `TypeckTables` node for some particular fn, so you might write:
+
+```text
+RUST_DEP_GRAPH_FILTER='-> TypeckTables & bar'
+```
+
+This will select only the predecessors of `TypeckTables` nodes for functions
+with `bar` in their name.
+
+Perhaps you are finding that when you change `foo` you need to re-type-check
+`bar`, but you don't think you should have to. In that case, you might do:
+
+```text
+RUST_DEP_GRAPH_FILTER='Hir & foo -> TypeckTables & bar'
+```
+
+This will dump out all the nodes that lead from `Hir(foo)` to
+`TypeckTables(bar)`, from which you can (hopefully) see the source
+of the erroneous edge.
+
+### Tracking down incorrect edges
+
+Sometimes, after you dump the dependency graph, you will find some
+path that should not exist, but you will not be quite sure how it came
+to be. **When the compiler is built with debug assertions,** it can
+help you track that down. Simply set the `RUST_FORBID_DEP_GRAPH_EDGE`
+environment variable to a filter. Every edge created in the dep-graph
+will be tested against that filter – if it matches, a `bug!` is
+reported, so you can easily see the backtrace (`RUST_BACKTRACE=1`).
+
+The syntax for these filters is the same as described in the previous
+section. However, note that this filter is applied to every **edge**
+and doesn't handle longer paths in the graph, unlike the previous
+section.
+
+Example:
+
+You find that there is a path from the `Hir` of `foo` to the type
+check of `bar` and you don't think there should be. You dump the
+dep-graph as described in the previous section and open `dep-graph.txt`
+to see something like:
+
+```text
+Hir(foo) -> Collect(bar)
+Collect(bar) -> TypeckTables(bar)
+```
+
+That first edge looks suspicious to you. So you set
+`RUST_FORBID_DEP_GRAPH_EDGE` to `Hir&foo -> Collect&bar`, re-run, and
+then observe the backtrace. Voila, bug fixed!
diff --git a/src/doc/rustc-dev-guide/src/lang-items.md b/src/doc/rustc-dev-guide/src/lang-items.md
new file mode 100644
index 000000000..867c42144
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/lang-items.md
@@ -0,0 +1,67 @@
+# Lang items
+
+The compiler has certain pluggable operations; that is, functionality that isn't hard-coded into
+the language, but is implemented in libraries, with a special marker to tell the compiler it
+exists. The marker is the attribute `#[lang = "..."]`, and there are various different values of
+`...`, i.e. various different 'lang items'.
+
+Many such lang items can be implemented only in one sensible way, such as `add` (`trait
+core::ops::Add`) or `future_trait` (`trait core::future::Future`). Others can be overridden to
+achieve some specific goals; for example, you can control your binary's entrypoint.
+
+Features provided by lang items include:
+
+- overloadable operators via traits: the traits corresponding to the
+  `==`, `<`, dereference (`*`), `+`, etc. operators are all
+  marked with lang items; those specific four are `eq`, `ord`,
+  `deref`, and `add` respectively.
+- panicking and stack unwinding; the `eh_personality`, `panic` and
+  `panic_bounds_checks` lang items.
+- the traits in `std::marker` used to indicate properties of types used by the compiler;
+  lang items `send`, `sync` and `copy`.
+- the special marker types used for variance indicators found in
+  `core::marker`; lang item `phantom_data`.
+
+Lang items are loaded lazily by the compiler; e.g. if one never uses `Box`
+then there is no need to define functions for `exchange_malloc` and
+`box_free`. `rustc` will emit an error when an item is needed but not found
+in the current crate or any that it depends on.
+
+Most lang items are defined by the `core` library, but if you're trying to build an
+executable with `#![no_std]`, you'll still need to define a few lang items that are
+usually provided by `std`.
+
+## Retrieving a language item
+
+You can retrieve lang items by calling [`tcx.lang_items()`].
+
+Here's a small example of retrieving the `trait Sized {}` language item:
+
+```rust
+// Note that in case of `#![no_core]`, the trait is not available.
+if let Some(sized_trait_def_id) = tcx.lang_items().sized_trait() {
+    // do something with `sized_trait_def_id`
+}
+```
+
+Note that `sized_trait()` returns an `Option`, not the `DefId` itself.
+That's because language items are defined in the standard library, so if someone compiles with
+`#![no_core]` (or for some lang items, `#![no_std]`), the lang item may not be present.
+You can either:
+
+- Give a hard error if the lang item is necessary to continue (don't panic, since this can happen in
+  user code).
+- Proceed with limited functionality, by just omitting whatever you were going to do with the
+  `DefId`.
+
+[`tcx.lang_items()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.lang_items
+
+## List of all language items
+
+You can find language items in the following places:
+- An exhaustive reference in the compiler documentation: [`rustc_hir::LangItem`]
+- An auto-generated list with source locations by using ripgrep: `rg '#\[.*lang =' library/`
+
+Note that language items are explicitly unstable and may change in any new release.
+
+[`rustc_hir::LangItem`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/lang_items/enum.LangItem.html
diff --git a/src/doc/rustc-dev-guide/src/licenses.md b/src/doc/rustc-dev-guide/src/licenses.md
new file mode 100644
index 000000000..06cd8ae6b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/licenses.md
@@ -0,0 +1,5 @@
+# `rust-lang/rust` Licenses
+
+The `rustc` compiler source and standard library are dual licensed under the [Apache License v2.0](https://github.com/rust-lang/rust/blob/master/LICENSE-APACHE) and the [MIT License](https://github.com/rust-lang/rust/blob/master/LICENSE-MIT) unless otherwise specified.
+
+Detailed licensing information is available in the [COPYRIGHT document](https://github.com/rust-lang/rust/blob/master/COPYRIGHT) of the `rust-lang/rust` repository.
diff --git a/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
new file mode 100644
index 000000000..ea4bdfca6
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
@@ -0,0 +1,627 @@
+# LLVM Source-Based Code Coverage
+
+<!-- toc -->
+
+`rustc` supports detailed source-based code and test coverage analysis
+with a command line option (`-C instrument-coverage`) that instruments Rust
+libraries and binaries with additional instructions and data, at compile time.
+
+The coverage instrumentation injects calls to the LLVM intrinsic instruction
+[`llvm.instrprof.increment`][llvm-instrprof-increment] at code branches
+(based on a MIR-based control flow analysis), and LLVM converts these to
+instructions that increment static counters, when executed. The LLVM coverage
+instrumentation also requires a [Coverage Map] that encodes source metadata,
+mapping counter IDs--directly and indirectly--to the file locations (with
+start and end line and column).
+
+Rust libraries, with or without coverage instrumentation, can be linked into
+instrumented binaries. When the program is executed and cleanly terminates,
+LLVM libraries write the final counter values to a file (`default.profraw` or
+a custom file set through environment variable `LLVM_PROFILE_FILE`).
+
+Developers use existing LLVM coverage analysis tools to decode `.profraw`
+files, with corresponding Coverage Maps (from matching binaries that produced
+them), and generate various reports for analysis, for example:
+
+<img alt="Screenshot of sample `llvm-cov show` result, for function add_quoted_string"
+ src="img/llvm-cov-show-01.png" class="center"/>
+<br/>
+
+Detailed instructions and examples are documented in the
+[Rustc Book][rustc-book-instrument-coverage].
+
+[llvm-instrprof-increment]: https://llvm.org/docs/LangRef.html#llvm-instrprof-increment-intrinsic
+[coverage map]: https://llvm.org/docs/CoverageMappingFormat.html
+[rustc-book-instrument-coverage]: https://doc.rust-lang.org/nightly/rustc/instrument-coverage.html
+
+## Rust symbol mangling
+
+`-C instrument-coverage` automatically enables Rust symbol mangling `v0` (as
+if the user specified `-C symbol-mangling-version=v0` option when invoking
+`rustc`) to ensure consistent and reversible name mangling. This has two
+important benefits:
+
+1. LLVM coverage tools can analyze coverage over multiple runs, including some
+   changes to source code; so mangled names must be consistent across compilations.
+2. LLVM coverage reports can report coverage by function, and even separates
+   out the coverage counts of each unique instantiation of a generic function,
+   if invoked with multiple type substitution variations.
+
+## Components of LLVM Coverage Instrumentation in `rustc`
+
+### LLVM Runtime Dependency
+
+Coverage data is only generated by running the executable Rust program. `rustc`
+statically links coverage-instrumented binaries with LLVM runtime code
+([compiler-rt][compiler-rt-profile]) that implements program hooks
+(such as an `exit` hook) to write the counter values to the `.profraw` file.
+
+In the `rustc` source tree, `library/profiler_builtins` bundles the LLVM
+`compiler-rt` code into a Rust library crate. (When building `rustc`, the
+`profiler_builtins` library is only included when `profiler = true` is set
+in `rustc`'s `config.toml`.)
+
+When compiling with `-C instrument-coverage`,
+[`CrateLoader::postprocess()`][crate-loader-postprocess] dynamically loads the
+`profiler_builtins` library by calling `inject_profiler_runtime()`.
+
+[compiler-rt-profile]: https://github.com/llvm/llvm-project/tree/main/compiler-rt/lib/profile
+[crate-loader-postprocess]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/creader/struct.CrateLoader.html#method.postprocess
+
+### MIR Pass: `InstrumentCoverage`
+
+Coverage instrumentation is performed on the MIR with a [MIR pass][mir-passes]
+called [`InstrumentCoverage`][mir-instrument-coverage]. This MIR pass analyzes
+the control flow graph (CFG)--represented by MIR `BasicBlock`s--to identify
+code branches, and injects additional [`Coverage`][coverage-statement]
+statements into the `BasicBlock`s.
+
+A MIR `Coverage` statement is a virtual instruction that indicates a counter
+should be incremented when its adjacent statements are executed, to count
+a span of code ([`CodeRegion`][code-region]). It counts the number of times a
+branch is executed, and also specifies the exact location of that code span in
+the Rust source code.
+
+Note that many of these `Coverage` statements will _not_ be converted into
+physical counters (or any other executable instructions) in the final binary.
+Some of them will be (see `CoverageKind::`[`Counter`][counter-coverage-kind]),
+but other counters can be computed on the fly, when generating a coverage
+report, by mapping a `CodeRegion` to a
+`CoverageKind`::[`Expression`][expression-coverage-kind].
+
+As an example:
+
+```rust
+fn some_func(flag: bool) {
+    // increment Counter(1)
+    ...
+    if flag {
+        // increment Counter(2)
+        ...
+    } else {
+        // count = Expression(1) = Counter(1) - Counter(2)
+        ...
+    }
+    // count = Expression(2) = Counter(1) + Zero
+    //     or, alternatively, Expression(2) = Counter(2) + Expression(1)
+    ...
+}
+```
+
+In this example, four contiguous code regions are counted while only
+incrementing two counters.
+
+CFG analysis is used to not only determine _where_ the branches are, for
+conditional expressions like `if`, `else`, `match`, and `loop`, but also to
+determine where expressions can be used in place of physical counters.
+
+The advantages of optimizing coverage through expressions are more pronounced
+with loops. Loops generally include at least one conditional branch that
+determines when to break out of a loop (a `while` condition, or an `if` or
+`match` with a `break`). In MIR, this is typically lowered to a `SwitchInt`,
+with one branch to stay in the loop, and another branch to break out of the
+loop. The branch that breaks out will almost always execute less often,
+so `InstrumentCoverage` chooses to add a `Counter` to that branch, and an
+`Expression(continue) = Counter(loop) - Counter(break)` to the branch that
+continues.
+
+The `InstrumentCoverage` MIR pass is documented in
+[more detail below][instrument-coverage-pass-details].
+
+[mir-passes]: mir/passes.md
+[mir-instrument-coverage]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_mir_transform/src/coverage
+[code-region]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/coverage/struct.CodeRegion.html
+[counter-coverage-kind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/coverage/enum.CoverageKind.html#variant.Counter
+[expression-coverage-kind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/coverage/enum.CoverageKind.html#variant.Expression
+[coverage-statement]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.StatementKind.html#variant.Coverage
+[instrument-coverage-pass-details]: #implementation-details-of-the-instrumentcoverage-mir-pass
+
+### Counter Injection and Coverage Map Pre-staging
+
+When the compiler enters [the Codegen phase][backend-lowering-mir], with a
+coverage-enabled MIR, [`codegen_statement()`][codegen-statement] converts each
+MIR `Statement` into some backend-specific action or instruction.
+`codegen_statement()` forwards `Coverage` statements to
+[`codegen_coverage()`][codegen-coverage]:
+
+```rust
+    pub fn codegen_statement(&mut self, mut bx: Bx, statement: &mir::Statement<'tcx>) -> Bx {
+        ...
+        match statement.kind {
+            ...
+            mir::StatementKind::Coverage(box ref coverage) => {
+                self.codegen_coverage(&mut bx, coverage.clone(), statement.source_info.scope);
+                bx
+            }
+```
+
+`codegen_coverage()` handles each `CoverageKind` as follows:
+
+- For all `CoverageKind`s, Coverage data (counter ID, expression equation
+  and ID, and code regions) are passed to the backend's `Builder`, to
+  populate data structures that will be used to generate the crate's
+  "Coverage Map". (See the [`FunctionCoverage`][function-coverage] `struct`.)
+- For `CoverageKind::Counter`s, an instruction is injected in the backend
+  IR to increment the physical counter, by calling the `BuilderMethod`
+  [`instrprof_increment()`][instrprof-increment].
+
+```rust
+    pub fn codegen_coverage(&self, bx: &mut Bx, coverage: Coverage, scope: SourceScope) {
+        ...
+        let instance = ... // the scoped instance (current or inlined function)
+        let Coverage { kind, code_region } = coverage;
+        match kind {
+            CoverageKind::Counter { function_source_hash, id } => {
+                ...
+                bx.add_coverage_counter(instance, id, code_region);
+                ...
+                bx.instrprof_increment(fn_name, hash, num_counters, index);
+            }
+            CoverageKind::Expression { id, lhs, op, rhs } => {
+                bx.add_coverage_counter_expression(instance, id, lhs, op, rhs, code_region);
+            }
+            CoverageKind::Unreachable => {
+                bx.add_coverage_unreachable(
+                    instance,
+                    code_region.expect(...
+```
+
+> The function name `instrprof_increment()` is taken from the LLVM intrinsic
+call of the same name ([`llvm.instrprof.increment`][llvm-instrprof-increment]),
+and uses the same arguments and types; but note that, up to and through this
+stage (even though modeled after LLVM's implementation for code coverage
+instrumentation), the data and instructions are not strictly LLVM-specific.
+>
+> But since LLVM is the only Rust-supported backend with the tooling to
+process this form of coverage instrumentation, the backend for `Coverage`
+statements is only implemented for LLVM, at this time.
+
+[backend-lowering-mir]: backend/lowering-mir.md
+[codegen-statement]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/struct.FunctionCx.html#method.codegen_statement
+[codegen-coverage]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/struct.FunctionCx.html#method.codegen_coverage
+[function-coverage]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/coverageinfo/map/struct.FunctionCoverage.html
+[instrprof-increment]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/traits/trait.BuilderMethods.html#tymethod.instrprof_increment
+
+### Coverage Map Generation
+
+With the instructions to increment counters now implemented in LLVM IR,
+the last remaining step is to inject the LLVM IR variables that hold the
+static data for the coverage map.
+
+`rustc_codegen_llvm`'s [`compile_codegen_unit()`][compile-codegen-unit] calls
+[`coverageinfo_finalize()`][coverageinfo-finalize],
+which delegates its implementation to the
+[`rustc_codegen_llvm::coverageinfo::mapgen`][mapgen-finalize] module.
+
+For each function `Instance` (code-generated from MIR, including multiple
+instances of the same MIR for generic functions that have different type
+substitution combinations), `mapgen`'s `finalize()` method queries the
+`Instance`-associated `FunctionCoverage` for its `Counter`s, `Expression`s,
+and `CodeRegion`s; and calls LLVM codegen APIs to generate
+properly-configured variables in LLVM IR, according to very specific
+details of the [_LLVM Coverage Mapping Format_][coverage-mapping-format]
+(Version 6).[^llvm-and-covmap-versions]
+
+[^llvm-and-covmap-versions]: The Rust compiler (as of <!-- date: 2021-12 -->
+December 2021) supports _LLVM Coverage Mapping Format_ Version 5 or 6. Version 5
+was introduced in _LLVM 12_, which is (as of this writing) the minimum LLVM
+version supported by the current version of Rust. Version 6 was introduced in
+_LLVM 13_, which is currently the default LLVM version for Rust. The Rust
+compiler will automatically use the most up-to-date coverage mapping format
+version that is compatible with the compiler's built-in version of LLVM.
+
+```rust
+pub fn finalize<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
+    ...
+    if !tcx.sess.instrument_coverage_except_unused_functions() {
+        add_unused_functions(cx);
+    }
+
+    let mut function_coverage_map = match cx.coverage_context() {
+        Some(ctx) => ctx.take_function_coverage_map(),
+        None => return,
+    };
+    ...
+    let mut mapgen = CoverageMapGenerator::new();
+
+    for (instance, function_coverage) in function_coverage_map {
+        ...
+        let coverage_mapping_buffer = llvm::build_byte_buffer(|coverage_mapping_buffer| {
+            mapgen.write_coverage_mapping(expressions, counter_regions, coverage_mapping_buffer);
+        });
+```
+_code snippet trimmed for brevity_
+
+One notable first step performed by `mapgen::finalize()` is the call to
+[`add_unused_functions()`][add-unused-functions]:
+
+When finalizing the coverage map, `FunctionCoverage` only has the `CodeRegion`s
+and counters for the functions that went through codegen; such as public
+functions and "used" functions (functions referenced by other "used" or public
+items). Any other functions (considered unused) were still parsed and processed
+through the MIR stage.
+
+The set of unused functions is computed via the set difference of all MIR
+`DefId`s (`tcx` query `mir_keys`) minus the codegenned `DefId`s (`tcx` query
+`codegened_and_inlined_items`). `add_unused_functions()` computes the set of
+unused functions, queries the `tcx` for the previously-computed `CodeRegions`,
+for each unused MIR, synthesizes an LLVM function (with no internal statements,
+since it will not be called), and adds a new `FunctionCoverage`, with
+`Unreachable` code regions.
+
+[compile-codegen-unit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/base/fn.compile_codegen_unit.html
+[coverageinfo-finalize]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/context/struct.CodegenCx.html#method.coverageinfo_finalize
+[mapgen-finalize]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/coverageinfo/mapgen/fn.finalize.html
+[coverage-mapping-format]: https://llvm.org/docs/CoverageMappingFormat.html
+[add-unused-functions]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/coverageinfo/mapgen/fn.add_unused_functions.html
+
+## Testing LLVM Coverage
+
+Coverage instrumentation in the MIR is validated by a `mir-opt` test:
+[`instrument-coverage`][mir-opt-test].
+
+More complete testing of end-to-end coverage instrumentation and reports are
+done in the `run-make-fulldeps` tests, with sample Rust programs (to be
+instrumented) in the [`coverage`][coverage-test-samples] directory, and the
+actual tests and expected results in [`coverage-reports`].
+
+Finally, the [`coverage-llvmir`] test compares compiles a simple Rust program
+with `-C instrument-coverage` and compares the compiled program's LLVM IR to
+expected LLVM IR instructions and structured data for a coverage-enabled
+program, including various checks for Coverage Map-related metadata and the LLVM
+intrinsic calls to increment the runtime counters.
+
+Expected results for both the `mir-opt` tests and the `coverage*` tests under
+`run-make-fulldeps` can be refreshed by running:
+
+```shell
+$ ./x.py test mir-opt --bless
+$ ./x.py test src/test/run-make-fulldeps/coverage --bless
+```
+
+[mir-opt-test]: https://github.com/rust-lang/rust/blob/master/src/test/mir-opt/instrument_coverage.rs
+[coverage-test-samples]: https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps/coverage
+[`coverage-reports`]: https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps/coverage-reports
+[`coverage-spanview`]: https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps/coverage-spanview
+[spanview-debugging]: compiler-debugging.md#viewing-spanview-output
+[`coverage-llvmir`]: https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps/coverage-llvmir
+
+## Implementation Details of the `InstrumentCoverage` MIR Pass
+
+The bulk of the implementation of the `InstrumentCoverage` MIR pass is performed
+by the [`Instrumentor`][instrumentor]. For each MIR (each non-const, non-inlined
+function, generic, or closure), the `Instrumentor`'s constructor prepares a
+[`CoverageGraph`][coverage-graph] and then executes
+[`inject_counters()`][inject-counters].
+
+```rust
+        Instrumentor::new(&self.name(), tcx, mir_body).inject_counters();
+```
+
+The `CoverageGraph` is a coverage-specific simplification of the MIR control
+flow graph (CFG). Its nodes are [`BasicCoverageBlock`s][bcb], which
+encompass one or more sequentially-executed MIR `BasicBlock`s
+(with no internal branching), plus a `CoverageKind` counter (to
+be added, via coverage analysis), and an optional set of additional counters
+to count incoming edges (if there are more than one).
+
+The `Instrumentor`'s `inject_counters()` uses the `CoverageGraph` to
+compute the best places to inject coverage counters, as MIR `Statement`s,
+with the following steps:
+
+1. Depending on the debugging configurations in `rustc`'s, `config.toml`,
+   and `rustc` command line flags, various debugging features may be enabled
+   to enhance `debug!()` messages in logs, and to generate various "dump" files,
+   to help developers understand the MIR transformation process for coverage.
+   Most of the debugging features are implemented in the [`debug`][debug]
+   sub-module.
+2. [`generate_coverage_spans()`][generate-coverage-spans] computes the minimum set of distinct,
+   non-branching code regions, from the MIR. These `CoverageSpan`s
+   represent a span of code that must be counted.
+3. [`make_bcb_counters()`][make-bcb-counters] generates `CoverageKind::Counter`s and
+   `CoverageKind::Expression`s for each `CoverageSpan`, plus additional
+   `intermediate_expressions`[^intermediate-expressions], not associated with any `CodeRegion`, but
+   are required to compute a final `Expression` value for a `CodeRegion`.
+4. Inject the new counters into the MIR, as new `StatementKind::Coverage`
+   statements. This is done by three distinct functions:
+   - `inject_coverage_span_counters()`
+   - `inject_indirect_counters()`
+   - `inject_intermediate_expression()`, called for each intermediate expression
+     returned from `make_bcb_counters()`
+
+[^intermediate-expressions]: Intermediate expressions are sometimes required
+because `Expression`s are limited to binary additions or subtractions. For
+example, `A + (B - C)` might represent an `Expression` count computed from three
+other counters, `A`, `B`, and `C`, but computing that value requires an
+intermediate expression for `B - C`.
+
+[instrumentor]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/struct.Instrumentor.html
+[coverage-graph]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/graph/struct.CoverageGraph.html
+[inject-counters]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/struct.Instrumentor.html#method.inject_counters
+[bcb]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/graph/struct.BasicCoverageBlock.html
+[debug]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/debug
+[generate-coverage-spans]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/spans/struct.CoverageSpans.html#method.generate_coverage_spans
+[make-bcb-counters]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/counters/struct.BcbCounters.html#method.make_bcb_counters
+
+### The `CoverageGraph`
+
+The [`CoverageGraph`][coverage-graph] is derived from the MIR (`mir::Body`).
+
+```rust
+        let basic_coverage_blocks = CoverageGraph::from_mir(mir_body);
+```
+
+Like `mir::Body`, the `CoverageGraph` is also a
+[`DirectedGraph`][directed-graph]. Both graphs represent the function's
+fundamental control flow, with many of the same
+[`graph trait`][graph-traits]s, supporting `start_node()`, `num_nodes()`,
+`successors()`, `predecessors()`, and `is_dominated_by()`.
+
+For anyone that knows how to work with the [MIR, as a CFG][mir-dev-guide], the
+`CoverageGraph` will be familiar, and can be used in much the same way.
+The nodes of the `CoverageGraph` are `BasicCoverageBlock`s (BCBs), which
+index into an `IndexVec` of `BasicCoverageBlockData`. This is analogous
+to the MIR CFG of `BasicBlock`s that index `BasicBlockData`.
+
+Each `BasicCoverageBlockData` captures one or more MIR `BasicBlock`s,
+exclusively, and represents the maximal-length sequence of `BasicBlocks`
+without conditional branches.
+
+[`compute_basic_coverage_blocks()`][compute-basic-coverage-blocks] builds the
+`CoverageGraph` as a coverage-specific simplification of the MIR CFG. In
+contrast with the [`SimplifyCfg`][simplify-cfg] MIR pass, this step does
+not alter the MIR itself, because the `CoverageGraph` aggressively simplifies
+the CFG, and ignores nodes that are not relevant to coverage. For example:
+
+  - The BCB CFG ignores (excludes) branches considered not relevant
+    to the current coverage solution. It excludes unwind-related code[^78544]
+    that is injected by the Rust compiler but has no physical source
+    code to count, which allows a `Call`-terminated BasicBlock
+    to be merged with its successor, within a single BCB.
+  - A `Goto`-terminated `BasicBlock` can be merged with its successor
+    **_as long as_** it has the only incoming edge to the successor
+    `BasicBlock`.
+  - Some BasicBlock terminators support Rust-specific concerns--like
+    borrow-checking--that are not relevant to coverage analysis. `FalseUnwind`,
+    for example, can be treated the same as a `Goto` (potentially merged with
+    its successor into the same BCB).
+
+[^78544]: (Note, however, that Issue [#78544][rust-lang/rust#78544] considers
+providing future support for coverage of programs that intentionally
+`panic`, as an option, with some non-trivial cost.)
+
+The BCB CFG is critical to simplifying the coverage analysis by ensuring graph path-based
+queries (`is_dominated_by()`, `predecessors`, `successors`, etc.) have branch (control flow)
+significance.
+
+To visualize the `CoverageGraph`, you can generate a _graphviz_ `*.dot`
+file with the following `rustc` flags:[^graphviz-dark-mode]
+
+[^graphviz-dark-mode]: This image also applies `-Z graphviz-dark-mode`, to
+produce a Graphviz document with "dark mode" styling. If you use a dark mode or
+theme in your development environment, you will probably want to use this
+option so you can review the graphviz output without straining your vision.
+
+```shell
+$ rustc -C instrument-coverage -Z dump-mir=InstrumentCoverage \
+    -Z dump-mir-graphviz some_rust_source.rs
+```
+
+The `-Z dump-mir` flag requests [MIR debugging
+output][mir-debugging] (generating `*.mir` files, by default).
+`-Z dump-mir-graphviz` additionally generates `*.dot` files.
+`-Z dump-mir=InstrumentCoverage` restricts these files to the
+`InstrumentCoverage` pass. All files are written to the `./mir_dump/`
+directory, by default.
+
+Files with names ending in `.-------.InstrumentCoverage.0.dot` contain the
+_graphviz_ representations of a `CoverageGraph` (one for each MIR, that is,
+for each function and closure):
+
+<img alt="cropped image of a sample CoverageGraph in graphviz format"
+ src="img/coverage-graphviz-01.png" style="border: 1px solid gray" class="center"/>
+<br/>
+
+This image shows each `BasicCoverageBlock` as a rectangular _node_, with
+directional edges (the arrows) leading from each node to its `successors()`.
+The nodes contain information in sections:
+
+1. The gray header has a label showing the BCB ID (or _index_ for looking up
+   its `BasicCoverageBlockData`).
+2. The first content section shows the assigned `Counter` or `Expression` for
+   each contiguous section of code. (There may be more than one `Expression`
+   incremented by the same `Counter` for noncontiguous sections of code
+   representing the same sequential actions.) Note the code is represented by
+   the line and column ranges (for example: `52:28-52:33`, representing the
+   original source line 52, for columns 28-33). These are followed by the MIR
+   `Statement` or `Terminator` represented by that source range. (How these
+   coverage regions are determined is discussed in the following section.)
+3. The final section(s) show the MIR `BasicBlock`s (by ID/index and its
+   `TerminatorKind`) contained in this BCB. The last BCB is separated out
+   because its `successors()` determine the edges leading out of the BCB, and
+   into the `leading_bb()` (first `BasicBlock`) of each successor BCB.
+
+Note, to find the `BasicCoverageBlock` from a final BCB `Terminator`'s
+successor `BasicBlock`, there is an index and helper
+function--[`bcb_from_bb()`][bcb-from-bb]--to look up a `BasicCoverageBlock` from
+*any* contained `BasicBlock`.
+
+[directed-graph]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/graph/trait.DirectedGraph.html
+[graph-traits]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/graph/index.html#traits
+[mir-dev-guide]: mir/index.md
+[compute-basic-coverage-blocks]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/graph/struct.CoverageGraph.html#method.compute_basic_coverage_blocks
+[simplify-cfg]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/simplify/struct.SimplifyCfg.html
+[rust-lang/rust#78544]: https://github.com/rust-lang/rust/issues/78544
+[mir-debugging]: mir/debugging.md
+[bcb-from-bb]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/graph/struct.CoverageGraph.html#method.bcb_from_bb
+
+### `CoverageSpans`
+
+The `struct` [`CoverageSpans`][coverage-spans] builds and refines a final set of
+[`CoverageSpan`][coverage-span]s, each representing the largest contiguous `Span`
+of source within a single BCB. By definition--since each `Span` falls within a
+BCB, the `Span` is also non-branching; so if any code in that `Span` has executed,
+all code in the `Span` will have executed, the same number of times.
+
+[`CoverageSpans::generate_coverage_spans()`][generate-coverage-spans] constructs
+an initial set of `CoverageSpan`s from the `Span`s associated with each MIR
+`Statement` and `Terminator`.
+
+The final stage of `generate_coverage_spans()` is handled by
+[`to_refined_spans()`][to-refined-spans], which iterates through the `CoverageSpan`s,
+merges and de-duplicates them, and returns an optimal, minimal set of `CoverageSpan`s
+that can be used to assign coverage `Counter`s or `Expression`s, one-for-one.
+
+An visual, interactive representation of the final `CoverageSpan`s can be
+generated with the following `rustc` flags:
+
+```shell
+$ rustc -C instrument-coverage -Z dump-mir=InstrumentCoverage \
+    -Z dump-mir-spanview some_rust_source.rs
+```
+
+These flags request Spanview output for the `InstrumentCoverage` pass, and the
+resulting files (one for each MIR, that is, for each function or closure) can be
+found in the `mir_dump` directory (by default), with the extension:
+`.-------.InstrumentCoverage.0.html`.
+
+<img alt="cropped image of a sample Spanview in a browser"
+ src="img/coverage-spanview-01.png" style="border: 1px solid gray" class="center"/>
+<br/>
+
+The image above shows one such example. The orange and blue backgrounds
+highlight alternating `CoverageSpan`s from the refined set. Hovering over a
+line expands the output on that line to show the MIR `BasicBlock` IDs covered
+by each `CoverageSpan`. While hovering, the `CoverageSpan` under the pointer
+also has a _tooltip_ block of text, showing even more detail, including the
+MIR `Statement`s and `Terminator`s contributing to the `CoverageSpan`, and
+their individual `Span`s (which should be encapsulated within the code region
+of the refined `CoverageSpan`)
+
+[coverage-spans]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/spans/struct.CoverageSpans.html
+[coverage-span]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/spans/struct.CoverageSpan.html
+[to-refined-spans]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/spans/struct.CoverageSpans.html#method.to_refined_spans
+
+### `make_bcb_counters()`
+
+[`make_bcb_counters()`][make-bcb-counters] traverses the `CoverageGraph` and adds a
+`Counter` or `Expression` to every BCB. It uses _Control Flow Analysis_
+to determine where an `Expression` can be used in place of a `Counter`.
+`Expressions` have no runtime overhead, so if a viable expression (adding or
+subtracting two other counters or expressions) can compute the same result as
+an embedded counter, an `Expression` is preferred.
+
+[`TraverseCoverageGraphWithLoops`][traverse-coverage-graph-with-loops]
+provides a traversal order that ensures all `BasicCoverageBlock` nodes in a
+loop are visited before visiting any node outside that loop. The traversal
+state includes a `context_stack`, with the current loop's context information
+(if in a loop), as well as context for nested loops.
+
+Within loops, nodes with multiple outgoing edges (generally speaking, these
+are BCBs terminated in a `SwitchInt`) can be optimized when at least one
+branch exits the loop and at least one branch stays within the loop. (For an
+`if` or `while`, there are only two branches, but a `match` may have more.)
+
+A branch that does not exit the loop should be counted by `Expression`, if
+possible. Note that some situations require assigning counters to BCBs before
+they are visited by traversal, so the `counter_kind` (`CoverageKind` for
+a `Counter` or `Expression`) may have already been assigned, in which case
+one of the other branches should get the `Expression`.
+
+For a node with more than two branches (such as for more than two
+`match` patterns), only one branch can be optimized by `Expression`. All
+others require a `Counter` (unless its BCB `counter_kind` was previously
+assigned).
+
+A branch expression is derived from the equation:
+
+```text
+Counter(branching_node) = SUM(Counter(branches))
+```
+
+It's important to
+be aware that the `branches` in this equation are the outgoing _edges_
+from the `branching_node`, but a `branch`'s target node may have other
+incoming edges. Given the following graph, for example, the count for
+`B` is the sum of its two incoming edges:
+
+<img alt="Example graph with multiple incoming edges to a branch node"
+ src="img/coverage-branch-counting-01.png" class="center" style="width: 25%">
+<br/>
+
+In this situation, BCB node `B` may require an edge counter for its
+"edge from A", and that edge might be computed from an `Expression`,
+`Counter(A) - Counter(C)`. But an expression for the BCB _node_ `B`
+would be the sum of all incoming edges:
+
+```text
+Expression((Counter(A) - Counter(C)) + SUM(Counter(remaining_edges)))
+```
+
+Note that this is only one possible configuration. The actual choice
+of `Counter` vs. `Expression` also depends on the order of counter
+assignments, and whether a BCB or incoming edge counter already has
+its `Counter` or `Expression`.
+
+[bcb-counters]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/counters/struct.BcbCounters.html
+[traverse-coverage-graph-with-loops]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/graph/struct.TraverseCoverageGraphWithLoops.html
+
+### Injecting counters into a MIR `BasicBlock`
+
+With the refined `CoverageSpan`s, and after all `Counter`s and `Expression`s are
+created, the final step is to inject the `StatementKind::Coverage` statements
+into the MIR. There are three distinct sources, handled by the following
+functions:
+
+- [`inject_coverage_span_counters()`][inject-coverage-span-counters] injects the
+  counter from each `CoverageSpan`'s BCB.
+- [`inject_indirect_counters()`][inject-indirect-counters] injects counters
+  for any BCB not assigned to a `CoverageSpan`, and for all edge counters.
+  These counters don't have `CoverageSpan`s.
+- [`inject_intermediate_expression()`][inject-intermediate-expression] injects
+  the intermediate expressions returned from `make_bcb_counters()`. These
+  counters aren't associated with any BCB, edge, or `CoverageSpan`.
+
+These three functions inject the `Coverage` statements into the MIR.
+`Counter`s and `Expression`s with `CoverageSpan`s add `Coverage` statements
+to a corresponding `BasicBlock`, with a `CodeRegion` computed from the
+refined `Span` and current `SourceMap`.
+
+All other `Coverage` statements have a `CodeRegion` of `None`, but they
+still must be injected because they contribute to other `Expression`s.
+
+Finally, edge's with a `CoverageKind::Counter` require a new `BasicBlock`,
+so the counter is only incremented when traversing the branch edge.
+
+[inject-coverage-span-counters]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/struct.Instrumentor.html#method.inject_coverage_span_counters
+[inject-indirect-counters]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/struct.Instrumentor.html#method.inject_indirect_counters
+[inject-intermediate-expression]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/fn.inject_intermediate_expression.html
+
+### Additional Debugging Support
+
+See the
+[crate documentation for `rustc_mir::transform::coverage::debug`][coverage-debugging]
+for a detailed description of the debug output, logging, and configuration options
+available to developers working on the `InstrumentCoverage` pass.
+
+[coverage-debugging]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/coverage/debug/index.html
diff --git a/src/doc/rustc-dev-guide/src/lowering.md b/src/doc/rustc-dev-guide/src/lowering.md
new file mode 100644
index 000000000..f6885b922
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/lowering.md
@@ -0,0 +1,48 @@
+# Lowering
+
+The lowering step converts AST to [HIR](hir.html).
+This means many structures are removed if they are irrelevant
+for type analysis or similar syntax agnostic analyses. Examples
+of such structures include but are not limited to
+
+* Parenthesis
+    * Removed without replacement, the tree structure makes order explicit
+* `for` loops and `while (let)` loops
+    * Converted to `loop` + `match` and some `let` bindings
+* `if let`
+    * Converted to `match`
+* Universal `impl Trait`
+    * Converted to generic arguments
+      (but with some flags, to know that the user didn't write them)
+* Existential `impl Trait`
+    * Converted to a virtual `existential type` declaration
+
+Lowering needs to uphold several invariants in order to not trigger the
+sanity checks in `compiler/rustc_passes/src/hir_id_validator.rs`:
+
+1. A `HirId` must be used if created. So if you use the `lower_node_id`,
+  you *must* use the resulting `NodeId` or `HirId` (either is fine, since
+  any `NodeId`s in the `HIR` are checked for existing `HirId`s)
+2. Lowering a `HirId` must be done in the scope of the *owning* item.
+  This means you need to use `with_hir_id_owner` if you are creating parts
+  of an item other than the one being currently lowered. This happens for
+  example during the lowering of existential `impl Trait`
+3. A `NodeId` that will be placed into a HIR structure must be lowered,
+  even if its `HirId` is unused. Calling
+  `let _ = self.lower_node_id(node_id);` is perfectly legitimate.
+4. If you are creating new nodes that didn't exist in the `AST`, you *must*
+  create new ids for them. This is done by calling the `next_id` method,
+  which produces both a new `NodeId` as well as automatically lowering it
+  for you so you also get the `HirId`.
+
+If you are creating new `DefId`s, since each `DefId` needs to have a
+corresponding `NodeId`, it is advisable to add these `NodeId`s to the
+`AST` so you don't have to generate new ones during lowering. This has
+the advantage of creating a way to find the `DefId` of something via its
+`NodeId`. If lowering needs this `DefId` in multiple places, you can't
+generate a new `NodeId` in all those places because you'd also get a new
+`DefId` then. With a `NodeId` from the `AST` this is not an issue.
+
+Having the `NodeId` also allows the `DefCollector` to generate the `DefId`s
+instead of lowering having to do it on the fly. Centralizing the `DefId`
+generation in one place makes it easier to refactor and reason about.
diff --git a/src/doc/rustc-dev-guide/src/macro-expansion.md b/src/doc/rustc-dev-guide/src/macro-expansion.md
new file mode 100644
index 000000000..156df8d5f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/macro-expansion.md
@@ -0,0 +1,619 @@
+# Macro expansion
+
+<!-- toc -->
+
+> `rustc_ast`, `rustc_expand`, and `rustc_builtin_macros` are all undergoing
+> refactoring, so some of the links in this chapter may be broken.
+
+Rust has a very powerful macro system. In the previous chapter, we saw how the
+parser sets aside macros to be expanded (it temporarily uses [placeholders]).
+This chapter is about the process of expanding those macros iteratively until
+we have a complete AST for our crate with no unexpanded macros (or a compile
+error).
+
+[placeholders]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/placeholders/index.html
+
+First, we will discuss the algorithm that expands and integrates macro output
+into ASTs. Next, we will take a look at how hygiene data is collected. Finally,
+we will look at the specifics of expanding different types of macros.
+
+Many of the algorithms and data structures described below are in [`rustc_expand`],
+with basic data structures in [`rustc_expand::base`][base].
+
+Also of note, `cfg` and `cfg_attr` are treated specially from other macros, and are
+handled in [`rustc_expand::config`][cfg].
+
+[`rustc_expand`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/index.html
+[base]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/index.html
+[cfg]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/config/index.html
+
+## Expansion and AST Integration
+
+First of all, expansion happens at the crate level. Given a raw source code for
+a crate, the compiler will produce a massive AST with all macros expanded, all
+modules inlined, etc. The primary entry point for this process is the
+[`MacroExpander::fully_expand_fragment`][fef] method. With few exceptions, we
+use this method on the whole crate (see ["Eager Expansion"](#eager-expansion)
+below for more detailed discussion of edge case expansion issues).
+
+[`rustc_builtin_macros`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_builtin_macros/index.html
+[reb]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/build/index.html
+
+At a high level, [`fully_expand_fragment`][fef] works in iterations. We keep a
+queue of unresolved macro invocations (that is, macros we haven't found the
+definition of yet). We repeatedly try to pick a macro from the queue, resolve
+it, expand it, and integrate it back. If we can't make progress in an
+iteration, this represents a compile error.  Here is the [algorithm][original]:
+
+[fef]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/expand/struct.MacroExpander.html#method.fully_expand_fragment
+[original]: https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
+
+0. Initialize an `queue` of unresolved macros.
+1. Repeat until `queue` is empty (or we make no progress, which is an error):
+    0. [Resolve](./name-resolution.md) imports in our partially built crate as
+       much as possible.
+    1. Collect as many macro [`Invocation`s][inv] as possible from our
+       partially built crate (fn-like, attributes, derives) and add them to the
+       queue.
+    2. Dequeue the first element, and attempt to resolve it.
+    3. If it's resolved:
+        0. Run the macro's expander function that consumes a [`TokenStream`] or
+           AST and produces a [`TokenStream`] or [`AstFragment`] (depending on
+           the macro kind). (A `TokenStream` is a collection of [`TokenTree`s][tt],
+           each of which are a token (punctuation, identifier, or literal) or a
+           delimited group (anything inside `()`/`[]`/`{}`)).
+            - At this point, we know everything about the macro itself and can
+              call `set_expn_data` to fill in its properties in the global data;
+              that is the hygiene data associated with `ExpnId`. (See [the
+              "Hygiene" section below][hybelow]).
+        1. Integrate that piece of AST into the big existing partially built
+           AST. This is essentially where the "token-like mass" becomes a
+           proper set-in-stone AST with side-tables. It happens as follows:
+            - If the macro produces tokens (e.g. a proc macro), we parse into
+              an AST, which may produce parse errors.
+            - During expansion, we create `SyntaxContext`s (hierarchy 2). (See
+              [the "Hygiene" section below][hybelow])
+            - These three passes happen one after another on every AST fragment
+              freshly expanded from a macro:
+                - [`NodeId`]s are assigned by [`InvocationCollector`]. This
+                  also collects new macro calls from this new AST piece and
+                  adds them to the queue.
+                - ["Def paths"][defpath] are created and [`DefId`]s are
+                  assigned to them by [`DefCollector`].
+                - Names are put into modules (from the resolver's point of
+                  view) by [`BuildReducedGraphVisitor`].
+        2. After expanding a single macro and integrating its output, continue
+           to the next iteration of [`fully_expand_fragment`][fef].
+    4. If it's not resolved:
+        0. Put the macro back in the queue
+        1. Continue to next iteration...
+
+[defpath]: hir.md#identifiers-in-the-hir
+[`NodeId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html
+[`InvocationCollector`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/expand/struct.InvocationCollector.html
+[`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html
+[`DefCollector`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/def_collector/struct.DefCollector.html
+[`BuildReducedGraphVisitor`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/build_reduced_graph/struct.BuildReducedGraphVisitor.html
+[hybelow]: #hygiene-and-hierarchies
+[tt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/tokenstream/enum.TokenTree.html
+[`TokenStream`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/tokenstream/struct.TokenStream.html
+[inv]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/expand/struct.Invocation.html
+[`AstFragment`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/expand/enum.AstFragment.html
+
+### Error Recovery
+
+If we make no progress in an iteration, then we have reached a compilation
+error (e.g. an undefined macro). We attempt to recover from failures
+(unresolved macros or imports) for the sake of diagnostics. This allows
+compilation to continue past the first error, so that we can report more errors
+at a time. Recovery can't cause compilation to succeed. We know that it will
+fail at this point. The recovery happens by expanding unresolved macros into
+[`ExprKind::Err`][err].
+
+[err]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/enum.ExprKind.html#variant.Err
+
+### Name Resolution
+
+Notice that name resolution is involved here: we need to resolve imports and
+macro names in the above algorithm. This is done in
+[`rustc_resolve::macros`][mresolve], which resolves macro paths, validates
+those resolutions, and reports various errors (e.g. "not found" or "found, but
+it's unstable" or "expected x, found y"). However, we don't try to resolve
+other names yet. This happens later, as we will see in the [next
+chapter](./name-resolution.md).
+
+[mresolve]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/macros/index.html
+
+### Eager Expansion
+
+_Eager expansion_ means that we expand the arguments of a macro invocation
+before the macro invocation itself. This is implemented only for a few special
+built-in macros that expect literals; expanding arguments first for some of
+these macro results in a smoother user experience.  As an example, consider the
+following:
+
+```rust,ignore
+macro bar($i: ident) { $i }
+macro foo($i: ident) { $i }
+
+foo!(bar!(baz));
+```
+
+A lazy expansion would expand `foo!` first. An eager expansion would expand
+`bar!` first.
+
+Eager expansion is not a generally available feature of Rust.  Implementing
+eager expansion more generally would be challenging, but we implement it for a
+few special built-in macros for the sake of user experience.  The built-in
+macros are implemented in [`rustc_builtin_macros`], along with some other early
+code generation facilities like injection of standard library imports or
+generation of test harness. There are some additional helpers for building
+their AST fragments in [`rustc_expand::build`][reb]. Eager expansion generally
+performs a subset of the things that lazy (normal) expansion. It is done by
+invoking [`fully_expand_fragment`][fef] on only part of a crate (as opposed to
+whole crate, like we normally do).
+
+### Other Data Structures
+
+Here are some other notable data structures involved in expansion and integration:
+- [`ResolverExpand`] - a trait used to break crate dependencies. This allows the
+  resolver services to be used in [`rustc_ast`], despite [`rustc_resolve`] and
+  pretty much everything else depending on [`rustc_ast`].
+- [`ExtCtxt`]/[`ExpansionData`] - various intermediate data kept and used by expansion
+  infrastructure in the process of its work
+- [`Annotatable`] - a piece of AST that can be an attribute target, almost same
+  thing as AstFragment except for types and patterns that can be produced by
+  macros but cannot be annotated with attributes
+- [`MacResult`] - a "polymorphic" AST fragment, something that can turn into a
+  different `AstFragment` depending on its [`AstFragmentKind`] - item,
+  or expression, or pattern etc.
+
+[`rustc_ast`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/index.html
+[`rustc_resolve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/index.html
+[`ResolverExpand`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.ResolverExpand.html
+[`ExtCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/struct.ExtCtxt.html
+[`ExpansionData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/struct.ExpansionData.html
+[`Annotatable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/enum.Annotatable.html
+[`MacResult`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.MacResult.html
+[`AstFragmentKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/expand/enum.AstFragmentKind.html
+
+## Hygiene and Hierarchies
+
+If you have ever used C/C++ preprocessor macros, you know that there are some
+annoying and hard-to-debug gotchas! For example, consider the following C code:
+
+```c
+#define DEFINE_FOO struct Bar {int x;}; struct Foo {Bar bar;};
+
+// Then, somewhere else
+struct Bar {
+    ...
+};
+
+DEFINE_FOO
+```
+
+Most people avoid writing C like this – and for good reason: it doesn't
+compile. The `struct Bar` defined by the macro clashes names with the `struct
+Bar` defined in the code. Consider also the following example:
+
+```c
+#define DO_FOO(x) {\
+    int y = 0;\
+    foo(x, y);\
+    }
+
+// Then elsewhere
+int y = 22;
+DO_FOO(y);
+```
+
+Do you see the problem? We wanted to generate a call `foo(22, 0)`, but instead
+we got `foo(0, 0)` because the macro defined its own `y`!
+
+These are both examples of _macro hygiene_ issues. _Hygiene_ relates to how to
+handle names defined _within a macro_. In particular, a hygienic macro system
+prevents errors due to names introduced within a macro. Rust macros are hygienic
+in that they do not allow one to write the sorts of bugs above.
+
+At a high level, hygiene within the Rust compiler is accomplished by keeping
+track of the context where a name is introduced and used. We can then
+disambiguate names based on that context. Future iterations of the macro system
+will allow greater control to the macro author to use that context. For example,
+a macro author may want to introduce a new name to the context where the macro
+was called. Alternately, the macro author may be defining a variable for use
+only within the macro (i.e. it should not be visible outside the macro).
+
+[code_dir]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_expand/src/mbe
+[code_mp]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_parser
+[code_mr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_rules
+[code_parse_int]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_parser/struct.TtParser.html#method.parse_tt
+[parsing]: ./the-parser.html
+
+The context is attached to AST nodes. All AST nodes generated by macros have
+context attached. Additionally, there may be other nodes that have context
+attached, such as some desugared syntax (non-macro-expanded nodes are
+considered to just have the "root" context, as described below).
+Throughout the compiler, we use [`rustc_span::Span`s][span] to refer to code locations.
+This struct also has hygiene information attached to it, as we will see later.
+
+[span]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html
+
+Because macros invocations and definitions can be nested, the syntax context of
+a node must be a hierarchy. For example, if we expand a macro and there is
+another macro invocation or definition in the generated output, then the syntax
+context should reflect the nesting.
+
+However, it turns out that there are actually a few types of context we may
+want to track for different purposes. Thus, there are not just one but _three_
+expansion hierarchies that together comprise the hygiene information for a
+crate.
+
+All of these hierarchies need some sort of "macro ID" to identify individual
+elements in the chain of expansions. This ID is [`ExpnId`].  All macros receive
+an integer ID, assigned continuously starting from 0 as we discover new macro
+calls.  All hierarchies start at [`ExpnId::root()`][rootid], which is its own
+parent.
+
+[`rustc_span::hygiene`][hy] contains all of the hygiene-related algorithms
+(with the exception of some hacks in [`Resolver::resolve_crate_root`][hacks])
+and structures related to hygiene and expansion that are kept in global data.
+
+The actual hierarchies are stored in [`HygieneData`][hd]. This is a global
+piece of data containing hygiene and expansion info that can be accessed from
+any [`Ident`] without any context.
+
+
+[`ExpnId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.ExpnId.html
+[rootid]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.ExpnId.html#method.root
+[hd]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.HygieneData.html
+[hy]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/index.html
+[hacks]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/struct.Resolver.html#method.resolve_crate_root
+[`Ident`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Ident.html
+
+### The Expansion Order Hierarchy
+
+The first hierarchy tracks the order of expansions, i.e., when a macro
+invocation is in the output of another macro.
+
+Here, the children in the hierarchy will be the "innermost" tokens.  The
+[`ExpnData`] struct itself contains a subset of properties from both macro
+definition and macro call available through global data.
+[`ExpnData::parent`][edp] tracks the child -> parent link in this hierarchy.
+
+[`ExpnData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.ExpnData.html
+[edp]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.ExpnData.html#structfield.parent
+
+For example,
+
+```rust,ignore
+macro_rules! foo { () => { println!(); } }
+
+fn main() { foo!(); }
+```
+
+In this code, the AST nodes that are finally generated would have hierarchy:
+
+```
+root
+    expn_id_foo
+        expn_id_println
+```
+
+### The Macro Definition Hierarchy
+
+The second hierarchy tracks the order of macro definitions, i.e., when we are
+expanding one macro another macro definition is revealed in its output.  This
+one is a bit tricky and more complex than the other two hierarchies.
+
+[`SyntaxContext`][sc] represents a whole chain in this hierarchy via an ID.
+[`SyntaxContextData`][scd] contains data associated with the given
+`SyntaxContext`; mostly it is a cache for results of filtering that chain in
+different ways.  [`SyntaxContextData::parent`][scdp] is the child -> parent
+link here, and [`SyntaxContextData::outer_expns`][scdoe] are individual
+elements in the chain.  The "chaining operator" is
+[`SyntaxContext::apply_mark`][am] in compiler code.
+
+A [`Span`][span], mentioned above, is actually just a compact representation of
+a code location and `SyntaxContext`. Likewise, an [`Ident`] is just an interned
+[`Symbol`] + `Span` (i.e. an interned string + hygiene data).
+
+[`Symbol`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Symbol.html
+[scd]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContextData.html
+[scdp]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContextData.html#structfield.parent
+[sc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContext.html
+[scdoe]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContextData.html#structfield.outer_expn
+[am]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContext.html#method.apply_mark
+
+For built-in macros, we use the context:
+`SyntaxContext::empty().apply_mark(expn_id)`, and such macros are considered to
+be defined at the hierarchy root. We do the same for proc-macros because we
+haven't implemented cross-crate hygiene yet.
+
+If the token had context `X` before being produced by a macro then after being
+produced by the macro it has context `X -> macro_id`. Here are some examples:
+
+Example 0:
+
+```rust,ignore
+macro m() { ident }
+
+m!();
+```
+
+Here `ident` originally has context [`SyntaxContext::root()`][scr]. `ident` has
+context `ROOT -> id(m)` after it's produced by `m`.
+
+[scr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.SyntaxContext.html#method.root
+
+
+Example 1:
+
+```rust,ignore
+macro m() { macro n() { ident } }
+
+m!();
+n!();
+```
+In this example the `ident` has context `ROOT` originally, then `ROOT -> id(m)`
+after the first expansion, then `ROOT -> id(m) -> id(n)`.
+
+Example 2:
+
+Note that these chains are not entirely determined by their last element, in
+other words `ExpnId` is not isomorphic to `SyntaxContext`.
+
+```rust,ignore
+macro m($i: ident) { macro n() { ($i, bar) } }
+
+m!(foo);
+```
+
+After all expansions, `foo` has context `ROOT -> id(n)` and `bar` has context
+`ROOT -> id(m) -> id(n)`.
+
+Finally, one last thing to mention is that currently, this hierarchy is subject
+to the ["context transplantation hack"][hack]. Basically, the more modern (and
+experimental) `macro` macros have stronger hygiene than the older MBE system,
+but this can result in weird interactions between the two. The hack is intended
+to make things "just work" for now.
+
+[hack]: https://github.com/rust-lang/rust/pull/51762#issuecomment-401400732
+
+### The Call-site Hierarchy
+
+The third and final hierarchy tracks the location of macro invocations.
+
+In this hierarchy [`ExpnData::call_site`][callsite] is the child -> parent link.
+
+[callsite]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/hygiene/struct.ExpnData.html#structfield.call_site
+
+Here is an example:
+
+```rust,ignore
+macro bar($i: ident) { $i }
+macro foo($i: ident) { $i }
+
+foo!(bar!(baz));
+```
+
+For the `baz` AST node in the final output, the first hierarchy is `ROOT ->
+id(foo) -> id(bar) -> baz`, while the third hierarchy is `ROOT -> baz`.
+
+### Macro Backtraces
+
+Macro backtraces are implemented in [`rustc_span`] using the hygiene machinery
+in [`rustc_span::hygiene`][hy].
+
+[`rustc_span`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/index.html
+
+## Producing Macro Output
+
+Above, we saw how the output of a macro is integrated into the AST for a crate,
+and we also saw how the hygiene data for a crate is generated. But how do we
+actually produce the output of a macro? It depends on the type of macro.
+
+There are two types of macros in Rust:
+`macro_rules!` macros (a.k.a. "Macros By Example" (MBE)) and procedural macros
+(or "proc macros"; including custom derives). During the parsing phase, the normal
+Rust parser will set aside the contents of macros and their invocations. Later,
+macros are expanded using these portions of the code.
+
+Some important data structures/interfaces here:
+- [`SyntaxExtension`] - a lowered macro representation, contains its expander
+  function, which transforms a `TokenStream` or AST into another `TokenStream`
+  or AST + some additional data like stability, or a list of unstable features
+  allowed inside the macro.
+- [`SyntaxExtensionKind`] - expander functions may have several different
+  signatures (take one token stream, or two, or a piece of AST, etc). This is
+  an enum that lists them.
+- [`BangProcMacro`]/[`TTMacroExpander`]/[`AttrProcMacro`]/[`MultiItemModifier`] -
+  traits representing the expander function signatures.
+
+[`SyntaxExtension`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/struct.SyntaxExtension.html
+[`SyntaxExtensionKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/enum.SyntaxExtensionKind.html
+[`BangProcMacro`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.BangProcMacro.html
+[`TTMacroExpander`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.TTMacroExpander.html
+[`AttrProcMacro`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.AttrProcMacro.html
+[`MultiItemModifier`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/base/trait.MultiItemModifier.html
+
+## Macros By Example
+
+MBEs have their own parser distinct from the normal Rust parser. When macros
+are expanded, we may invoke the MBE parser to parse and expand a macro.  The
+MBE parser, in turn, may call the normal Rust parser when it needs to bind a
+metavariable (e.g.  `$my_expr`) while parsing the contents of a macro
+invocation. The code for macro expansion is in
+[`compiler/rustc_expand/src/mbe/`][code_dir].
+
+### Example
+
+It's helpful to have an example to refer to. For the remainder of this chapter,
+whenever we refer to the "example _definition_", we mean the following:
+
+```rust,ignore
+macro_rules! printer {
+    (print $mvar:ident) => {
+        println!("{}", $mvar);
+    };
+    (print twice $mvar:ident) => {
+        println!("{}", $mvar);
+        println!("{}", $mvar);
+    };
+}
+```
+
+`$mvar` is called a _metavariable_. Unlike normal variables, rather than
+binding to a value in a computation, a metavariable binds _at compile time_ to
+a tree of _tokens_.  A _token_ is a single "unit" of the grammar, such as an
+identifier (e.g. `foo`) or punctuation (e.g. `=>`). There are also other
+special tokens, such as `EOF`, which indicates that there are no more tokens.
+Token trees resulting from paired parentheses-like characters (`(`...`)`,
+`[`...`]`, and `{`...`}`) – they include the open and close and all the tokens
+in between (we do require that parentheses-like characters be balanced). Having
+macro expansion operate on token streams rather than the raw bytes of a source
+file abstracts away a lot of complexity. The macro expander (and much of the
+rest of the compiler) doesn't really care that much about the exact line and
+column of some syntactic construct in the code; it cares about what constructs
+are used in the code. Using tokens allows us to care about _what_ without
+worrying about _where_. For more information about tokens, see the
+[Parsing][parsing] chapter of this book.
+
+Whenever we refer to the "example _invocation_", we mean the following snippet:
+
+```rust,ignore
+printer!(print foo); // Assume `foo` is a variable defined somewhere else...
+```
+
+The process of expanding the macro invocation into the syntax tree
+`println!("{}", foo)` and then expanding that into a call to `Display::fmt` is
+called _macro expansion_, and it is the topic of this chapter.
+
+### The MBE parser
+
+There are two parts to MBE expansion: parsing the definition and parsing the
+invocations. Interestingly, both are done by the macro parser.
+
+Basically, the MBE parser is like an NFA-based regex parser. It uses an
+algorithm similar in spirit to the [Earley parsing
+algorithm](https://en.wikipedia.org/wiki/Earley_parser). The macro parser is
+defined in [`compiler/rustc_expand/src/mbe/macro_parser.rs`][code_mp].
+
+The interface of the macro parser is as follows (this is slightly simplified):
+
+```rust,ignore
+fn parse_tt(
+    &mut self,
+    parser: &mut Cow<'_, Parser<'_>>,
+    matcher: &[MatcherLoc]
+) -> ParseResult
+```
+
+We use these items in macro parser:
+
+- `parser` is a reference to the state of a normal Rust parser, including the
+  token stream and parsing session. The token stream is what we are about to
+  ask the MBE parser to parse. We will consume the raw stream of tokens and
+  output a binding of metavariables to corresponding token trees. The parsing
+  session can be used to report parser errors.
+- `matcher` is a sequence of `MatcherLoc`s that we want to match
+  the token stream against. They're converted from token trees before matching.
+
+In the analogy of a regex parser, the token stream is the input and we are matching it
+against the pattern `matcher`. Using our examples, the token stream could be the stream of
+tokens containing the inside of the example invocation `print foo`, while `matcher`
+might be the sequence of token (trees) `print $mvar:ident`.
+
+The output of the parser is a [`ParseResult`], which indicates which of
+three cases has occurred:
+
+- Success: the token stream matches the given `matcher`, and we have produced a binding
+  from metavariables to the corresponding token trees.
+- Failure: the token stream does not match `matcher`. This results in an error message such as
+  "No rule expected token _blah_".
+- Error: some fatal error has occurred _in the parser_. For example, this
+  happens if there are more than one pattern match, since that indicates
+  the macro is ambiguous.
+
+The full interface is defined [here][code_parse_int].
+
+The macro parser does pretty much exactly the same as a normal regex parser with
+one exception: in order to parse different types of metavariables, such as
+`ident`, `block`, `expr`, etc., the macro parser must sometimes call back to the
+normal Rust parser.
+
+As mentioned above, both definitions and invocations of macros are parsed using
+the macro parser. This is extremely non-intuitive and self-referential. The code
+to parse macro _definitions_ is in
+[`compiler/rustc_expand/src/mbe/macro_rules.rs`][code_mr]. It defines the pattern for
+matching for a macro definition as `$( $lhs:tt => $rhs:tt );+`. In other words,
+a `macro_rules` definition should have in its body at least one occurrence of a
+token tree followed by `=>` followed by another token tree. When the compiler
+comes to a `macro_rules` definition, it uses this pattern to match the two token
+trees per rule in the definition of the macro _using the macro parser itself_.
+In our example definition, the metavariable `$lhs` would match the patterns of
+both arms: `(print $mvar:ident)` and `(print twice $mvar:ident)`.  And `$rhs`
+would match the bodies of both arms: `{ println!("{}", $mvar); }` and `{
+println!("{}", $mvar); println!("{}", $mvar); }`. The parser would keep this
+knowledge around for when it needs to expand a macro invocation.
+
+When the compiler comes to a macro invocation, it parses that invocation using
+the same NFA-based macro parser that is described above. However, the matcher
+used is the first token tree (`$lhs`) extracted from the arms of the macro
+_definition_. Using our example, we would try to match the token stream `print
+foo` from the invocation against the matchers `print $mvar:ident` and `print
+twice $mvar:ident` that we previously extracted from the definition.  The
+algorithm is exactly the same, but when the macro parser comes to a place in the
+current matcher where it needs to match a _non-terminal_ (e.g. `$mvar:ident`),
+it calls back to the normal Rust parser to get the contents of that
+non-terminal. In this case, the Rust parser would look for an `ident` token,
+which it finds (`foo`) and returns to the macro parser. Then, the macro parser
+proceeds in parsing as normal. Also, note that exactly one of the matchers from
+the various arms should match the invocation; if there is more than one match,
+the parse is ambiguous, while if there are no matches at all, there is a syntax
+error.
+
+For more information about the macro parser's implementation, see the comments
+in [`compiler/rustc_expand/src/mbe/macro_parser.rs`][code_mp].
+
+### `macro`s and Macros 2.0
+
+There is an old and mostly undocumented effort to improve the MBE system, give
+it more hygiene-related features, better scoping and visibility rules, etc. There
+hasn't been a lot of work on this recently, unfortunately. Internally, `macro`
+macros use the same machinery as today's MBEs; they just have additional
+syntactic sugar and are allowed to be in namespaces.
+
+## Procedural Macros
+
+Procedural macros are also expanded during parsing, as mentioned above.
+However, they use a rather different mechanism. Rather than having a parser in
+the compiler, procedural macros are implemented as custom, third-party crates.
+The compiler will compile the proc macro crate and specially annotated
+functions in them (i.e. the proc macro itself), passing them a stream of tokens.
+
+The proc macro can then transform the token stream and output a new token
+stream, which is synthesized into the AST.
+
+It's worth noting that the token stream type used by proc macros is _stable_,
+so `rustc` does not use it internally (since our internal data structures are
+unstable). The compiler's token stream is
+[`rustc_ast::tokenstream::TokenStream`][rustcts], as previously. This is
+converted into the stable [`proc_macro::TokenStream`][stablets] and back in
+[`rustc_expand::proc_macro`][pm] and [`rustc_expand::proc_macro_server`][pms].
+Because the Rust ABI is unstable, we use the C ABI for this conversion.
+
+[tsmod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/tokenstream/index.html
+[rustcts]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/tokenstream/struct.TokenStream.html
+[stablets]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
+[pm]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/proc_macro/index.html
+[pms]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/proc_macro_server/index.html
+[`ParseResult`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/mbe/macro_parser/enum.ParseResult.html
+
+TODO: more here. [#1160](https://github.com/rust-lang/rustc-dev-guide/issues/1160)
+
+### Custom Derive
+
+Custom derives are a special type of proc macro.
+
+TODO: more? [#1160](https://github.com/rust-lang/rustc-dev-guide/issues/1160)
diff --git a/src/doc/rustc-dev-guide/src/memory.md b/src/doc/rustc-dev-guide/src/memory.md
new file mode 100644
index 000000000..cde2f454c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/memory.md
@@ -0,0 +1,88 @@
+# Memory Management in Rustc
+
+Rustc tries to be pretty careful how it manages memory. The compiler allocates
+_a lot_ of data structures throughout compilation, and if we are not careful,
+it will take a lot of time and space to do so.
+
+One of the main way the compiler manages this is using arenas and interning.
+
+## Arenas and  Interning
+
+We create a LOT of data structures during compilation. For performance reasons,
+we allocate them from a global memory pool; they are each allocated once from a
+long-lived *arena*. This is called _arena allocation_. This system reduces
+allocations/deallocations of memory. It also allows for easy comparison of
+types for equality: for each interned type `X`, we implemented [`PartialEq for
+X`][peqimpl], so we can just compare pointers. The [`CtxtInterners`] type
+contains a bunch of maps of interned types and the arena itself.
+
+[peqimpl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html#implementations
+[`CtxtInterners`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.CtxtInterners.html#structfield.arena
+
+### Example: `ty::TyS`
+
+Taking the example of [`ty::TyS`] which represents a type in the compiler (you
+can read more [here](./ty.md)).  Each time we want to construct a type, the
+compiler doesn’t naively allocate from the buffer.  Instead, we check if that
+type was already constructed. If it was, we just get the same pointer we had
+before, otherwise we make a fresh pointer. With this schema if we want to know
+if two types are the same, all we need to do is compare the pointers which is
+efficient. `TyS` is carefully setup so you never construct them on the stack.
+You always allocate them from this arena and you always intern them so they are
+unique.
+
+At the beginning of the compilation we make a buffer and each time we need to allocate a type we use
+some of this memory buffer. If we run out of space we get another one. The lifetime of that buffer
+is `'tcx`. Our types are tied to that lifetime, so when compilation finishes all the memory related
+to that buffer is freed and our `'tcx` references would be invalid.
+
+In addition to types, there are a number of other arena-allocated data structures that you can
+allocate, and which are found in this module. Here are a few examples:
+
+- [`Substs`][subst], allocated with `mk_substs` – this will intern a slice of types, often used to
+  specify the values to be substituted for generics (e.g. `HashMap<i32, u32>` would be represented
+  as a slice `&'tcx [tcx.types.i32, tcx.types.u32]`).
+- [`TraitRef`], typically passed by value – a **trait reference** consists of a reference to a trait
+  along with its various type parameters (including `Self`), like `i32: Display` (here, the def-id
+  would reference the `Display` trait, and the substs would contain `i32`). Note that `def-id` is
+  defined and discussed in depth in the `AdtDef and DefId` section.
+- [`Predicate`] defines something the trait system has to prove (see `traits` module).
+
+[subst]: ./generic_arguments.html#subst
+[`TraitRef`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TraitRef.html
+[`Predicate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Predicate.html
+
+[`ty::TyS`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
+
+## The tcx and how it uses lifetimes
+
+The `tcx` ("typing context") is the central data structure in the compiler. It is the context that
+you use to perform all manner of queries. The struct `TyCtxt` defines a reference to this shared
+context:
+
+```rust,ignore
+tcx: TyCtxt<'tcx>
+//          ----
+//          |
+//          arena lifetime
+```
+
+As you can see, the `TyCtxt` type takes a lifetime parameter. When you see a reference with a
+lifetime like `'tcx`, you know that it refers to arena-allocated data (or data that lives as long as
+the arenas, anyhow).
+
+### A Note On Lifetimes
+
+The Rust compiler is a fairly large program containing lots of big data
+structures (e.g. the AST, HIR, and the type system) and as such, arenas and
+references are heavily relied upon to minimize unnecessary memory use. This
+manifests itself in the way people can plug into the compiler (i.e. the
+[driver](./rustc-driver.md)), preferring a "push"-style API (callbacks) instead
+of the more Rust-ic "pull" style (think the `Iterator` trait).
+
+Thread-local storage and interning are used a lot through the compiler to reduce
+duplication while also preventing a lot of the ergonomic issues due to many
+pervasive lifetimes. The [`rustc_middle::ty::tls`][tls] module is used to access these
+thread-locals, although you should rarely need to touch it.
+
+[tls]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/tls/index.html
diff --git a/src/doc/rustc-dev-guide/src/method-lookup.md b/src/doc/rustc-dev-guide/src/method-lookup.md
new file mode 100644
index 000000000..8eb8ec5ce
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/method-lookup.md
@@ -0,0 +1,113 @@
+# Method lookup
+
+Method lookup can be rather complex due to the interaction of a number
+of factors, such as self types, autoderef, trait lookup, etc. This
+file provides an overview of the process. More detailed notes are in
+the code itself, naturally.
+
+One way to think of method lookup is that we convert an expression of
+the form `receiver.method(...)` into a more explicit [fully-qualified syntax][]
+(formerly called [UFCS][]):
+
+- `Trait::method(ADJ(receiver), ...)` for a trait call
+- `ReceiverType::method(ADJ(receiver), ...)` for an inherent method call
+
+Here `ADJ` is some kind of adjustment, which is typically a series of
+autoderefs and then possibly an autoref (e.g., `&**receiver`). However
+we sometimes do other adjustments and coercions along the way, in
+particular unsizing (e.g., converting from `[T; n]` to `[T]`).
+
+Method lookup is divided into two major phases:
+
+1. Probing ([`probe.rs`][probe]). The probe phase is when we decide what method
+   to call and how to adjust the receiver.
+2. Confirmation ([`confirm.rs`][confirm]). The confirmation phase "applies"
+   this selection, updating the side-tables, unifying type variables, and
+   otherwise doing side-effectful things.
+
+One reason for this division is to be more amenable to caching.  The
+probe phase produces a "pick" (`probe::Pick`), which is designed to be
+cacheable across method-call sites. Therefore, it does not include
+inference variables or other information.
+
+[fully-qualified syntax]: https://doc.rust-lang.org/nightly/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name
+[UFCS]: https://github.com/rust-lang/rfcs/blob/master/text/0132-ufcs.md
+[probe]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/check/method/probe/
+[confirm]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/check/method/confirm/
+
+## The Probe phase
+
+### Steps
+
+The first thing that the probe phase does is to create a series of
+*steps*. This is done by progressively dereferencing the receiver type
+until it cannot be deref'd anymore, as well as applying an optional
+"unsize" step. So if the receiver has type `Rc<Box<[T; 3]>>`, this
+might yield:
+
+1. `Rc<Box<[T; 3]>>`
+2. `Box<[T; 3]>`
+3. `[T; 3]`
+4. `[T]`
+
+### Candidate assembly
+
+We then search along those steps to create a list of *candidates*. A
+`Candidate` is a method item that might plausibly be the method being
+invoked. For each candidate, we'll derive a "transformed self type"
+that takes into account explicit self.
+
+Candidates are grouped into two kinds, inherent and extension.
+
+**Inherent candidates** are those that are derived from the
+type of the receiver itself.  So, if you have a receiver of some
+nominal type `Foo` (e.g., a struct), any methods defined within an
+impl like `impl Foo` are inherent methods.  Nothing needs to be
+imported to use an inherent method, they are associated with the type
+itself (note that inherent impls can only be defined in the same
+crate as the type itself).
+
+FIXME: Inherent candidates are not always derived from impls.  If you
+have a trait object, such as a value of type `Box<ToString>`, then the
+trait methods (`to_string()`, in this case) are inherently associated
+with it. Another case is type parameters, in which case the methods of
+their bounds are inherent. However, this part of the rules is subject
+to change: when DST's "impl Trait for Trait" is complete, trait object
+dispatch could be subsumed into trait matching, and the type parameter
+behavior should be reconsidered in light of where clauses.
+
+TODO: Is this FIXME still accurate?
+
+**Extension candidates** are derived from imported traits.  If I have
+the trait `ToString` imported, and I call `to_string()` as a method,
+then we will list the `to_string()` definition in each impl of
+`ToString` as a candidate. These kinds of method calls are called
+"extension methods".
+
+So, let's continue our example. Imagine that we were calling a method
+`foo` with the receiver `Rc<Box<[T; 3]>>` and there is a trait `Foo`
+that defines it with `&self` for the type `Rc<U>` as well as a method
+on the type `Box` that defines `foo` but with `&mut self`. Then we
+might have two candidates:
+
+- `&Rc<U>` as an extension candidate
+- `&mut Box<U>` as an inherent candidate
+
+### Candidate search
+
+Finally, to actually pick the method, we will search down the steps,
+trying to match the receiver type against the candidate types. At
+each step, we also consider an auto-ref and auto-mut-ref to see whether
+that makes any of the candidates match. For each resulting receiver
+type, we consider inherent candidates before extension candidates.
+If there are multiple matching candidates in a group, we report an
+error, except that multiple impls of the same trait are treated as a
+single match. Otherwise we pick the first match we find.
+
+In the case of our example, the first step is `Rc<Box<[T; 3]>>`,
+which does not itself match any candidate. But when we autoref it, we
+get the type `&Rc<Box<[T; 3]>>` which matches `&Rc<U>`. We would then
+recursively consider all where-clauses that appear on the impl: if
+those match (or we cannot rule out that they do), then this is the
+method we would pick. Otherwise, we would continue down the series of
+steps.
diff --git a/src/doc/rustc-dev-guide/src/mir/construction.md b/src/doc/rustc-dev-guide/src/mir/construction.md
new file mode 100644
index 000000000..d9f99be03
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/construction.md
@@ -0,0 +1,148 @@
+# MIR construction
+
+<!-- toc -->
+
+The lowering of [HIR] to [MIR] occurs for the following (probably incomplete)
+list of items:
+
+* Function and closure bodies
+* Initializers of `static` and `const` items
+* Initializers of enum discriminants
+* Glue and shims of any kind
+    * Tuple struct initializer functions
+    * Drop code (the `Drop::drop` function is not called directly)
+    * Drop implementations of types without an explicit `Drop` implementation
+
+The lowering is triggered by calling the [`mir_built`] query. The MIR builder does
+not actually use the HIR but operates on the [THIR] instead, processing THIR
+expressions recursively.
+
+The lowering creates local variables for every argument as specified in the signature.
+Next, it creates local variables for every binding specified (e.g. `(a, b): (i32, String)`)
+produces 3 bindings, one for the argument, and two for the bindings. Next, it generates
+field accesses that read the fields from the argument and writes the value to the binding
+variable.
+
+With this initialization out of the way, the lowering triggers a recursive call
+to a function that generates the MIR for the body (a `Block` expression) and
+writes the result into the `RETURN_PLACE`.
+
+## `unpack!` all the things
+
+Functions that generate MIR tend to fall into one of two patterns.
+First, if the function generates only statements, then it will take a
+basic block as argument onto which those statements should be appended.
+It can then return a result as normal:
+
+```rust,ignore
+fn generate_some_mir(&mut self, block: BasicBlock) -> ResultType {
+   ...
+}
+```
+
+But there are other functions that may generate new basic blocks as well.
+For example, lowering an expression like `if foo { 22 } else { 44 }`
+requires generating a small "diamond-shaped graph".
+In this case, the functions take a basic block where their code starts
+and return a (potentially) new basic block where the code generation ends.
+The `BlockAnd` type is used to represent this:
+
+```rust,ignore
+fn generate_more_mir(&mut self, block: BasicBlock) -> BlockAnd<ResultType> {
+    ...
+}
+```
+
+When you invoke these functions, it is common to have a local variable `block`
+that is effectively a "cursor". It represents the point at which we are adding new MIR.
+When you invoke `generate_more_mir`, you want to update this cursor.
+You can do this manually, but it's tedious:
+
+```rust,ignore
+let mut block;
+let v = match self.generate_more_mir(..) {
+    BlockAnd { block: new_block, value: v } => {
+        block = new_block;
+        v
+    }
+};
+```
+
+For this reason, we offer a macro that lets you write
+`let v = unpack!(block = self.generate_more_mir(...))`.
+It simply extracts the new block and overwrites the
+variable `block` that you named in the `unpack!`.
+
+## Lowering expressions into the desired MIR
+
+There are essentially four kinds of representations one might want of an expression:
+
+* `Place` refers to a (or part of a) preexisting memory location (local, static, promoted)
+* `Rvalue` is something that can be assigned to a `Place`
+* `Operand` is an argument to e.g. a `+` operation or a function call
+* a temporary variable containing a copy of the value
+
+The following image depicts a general overview of the interactions between the
+representations:
+
+<img src="mir_overview.svg">
+
+[Click here for a more detailed view](mir_detailed.svg)
+
+We start out with lowering the function body to an `Rvalue` so we can create an
+assignment to `RETURN_PLACE`, This `Rvalue` lowering will in turn trigger lowering to
+`Operand` for its arguments (if any). `Operand` lowering either produces a `const`
+operand, or moves/copies out of a `Place`, thus triggering a `Place` lowering. An
+expression being lowered to a `Place` can in turn trigger a temporary to be created
+if the expression being lowered contains operations. This is where the snake bites its
+own tail and we need to trigger an `Rvalue` lowering for the expression to be written
+into the local.
+
+## Operator lowering
+
+Operators on builtin types are not lowered to function calls (which would end up being
+infinite recursion calls, because the trait impls just contain the operation itself
+again). Instead there are `Rvalue`s for binary and unary operators and index operations.
+These `Rvalue`s later get codegened to llvm primitive operations or llvm intrinsics.
+
+Operators on all other types get lowered to a function call to their `impl` of the
+operator's corresponding trait.
+
+Regardless of the lowering kind, the arguments to the operator are lowered to `Operand`s.
+This means all arguments are either constants, or refer to an already existing value
+somewhere in a local or static.
+
+## Method call lowering
+
+Method calls are lowered to the same `TerminatorKind` that function calls are.
+In [MIR] there is no difference between method calls and function calls anymore.
+
+## Conditions
+
+`if` conditions and `match` statements for `enum`s without variants with fields are
+lowered to `TerminatorKind::SwitchInt`. Each possible value (so `0` and `1` for `if`
+conditions) has a corresponding `BasicBlock` to which the code continues.
+The argument being branched on is (again) an `Operand` representing the value of
+the if condition.
+
+### Pattern matching
+
+`match` statements for `enum`s with variants that have fields are lowered to
+`TerminatorKind::SwitchInt`, too, but the `Operand` refers to a `Place` where the
+discriminant of the value can be found. This often involves reading the discriminant
+to a new temporary variable.
+
+## Aggregate construction
+
+Aggregate values of any kind (e.g. structs or tuples) are built via `Rvalue::Aggregate`.
+All fields are
+lowered to `Operator`s. This is essentially equivalent to one assignment
+statement per aggregate field plus an assignment to the discriminant in the
+case of `enum`s.
+
+[MIR]: ./index.html
+[HIR]: ../hir.html
+[THIR]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/index.html
+
+[`rustc_mir_build::thir::cx::expr`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/cx/expr/index.html
+[`mir_built`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/build/fn.mir_built.html
diff --git a/src/doc/rustc-dev-guide/src/mir/dataflow.md b/src/doc/rustc-dev-guide/src/mir/dataflow.md
new file mode 100644
index 000000000..ce4a86a23
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/dataflow.md
@@ -0,0 +1,237 @@
+# Dataflow Analysis
+
+<!-- toc -->
+
+If you work on the MIR, you will frequently come across various flavors of
+[dataflow analysis][wiki]. `rustc` uses dataflow to find uninitialized
+variables, determine what variables are live across a generator `yield`
+statement, and compute which `Place`s are borrowed at a given point in the
+control-flow graph. Dataflow analysis is a fundamental concept in modern
+compilers, and knowledge of the subject will be helpful to prospective
+contributors.
+
+However, this documentation is not a general introduction to dataflow analysis.
+It is merely a description of the framework used to define these analyses in
+`rustc`. It assumes that the reader is familiar with the core ideas as well as
+some basic terminology, such as "transfer function", "fixpoint" and "lattice".
+If you're unfamiliar with these terms, or if you want a quick refresher,
+[*Static Program Analysis*] by Anders Møller and Michael I. Schwartzbach is an
+excellent, freely available textbook. For those who prefer audiovisual
+learning, we previously recommended a series of short lectures
+by the Goethe University Frankfurt on YouTube, but it has since been deleted.
+See [this PR][pr-1295] for the context and [this comment][pr-1295-comment]
+for the alternative lectures.
+
+## Defining a Dataflow Analysis
+
+The interface for dataflow analyses is split into three traits. The first is
+[`AnalysisDomain`], which must be implemented by *all* analyses. In addition to
+the type of the dataflow state, this trait defines the initial value of that
+state at entry to each block, as well as the direction of the analysis, either
+forward or backward. The domain of your dataflow analysis must be a [lattice][]
+(strictly speaking a join-semilattice) with a well-behaved `join` operator. See
+documentation for the [`lattice`] module, as well as the [`JoinSemiLattice`]
+trait, for more information.
+
+You must then provide *either* a direct implementation of the [`Analysis`] trait
+*or* an implementation of the proxy trait [`GenKillAnalysis`]. The latter is for
+so-called ["gen-kill" problems], which have a simple class of transfer function
+that can be applied very efficiently. Analyses whose domain is not a `BitSet`
+of some index type, or whose transfer functions cannot be expressed through
+"gen" and "kill" operations, must implement `Analysis` directly, and will run
+slower as a result. All implementers of `GenKillAnalysis` also implement
+`Analysis` automatically via a default `impl`.
+
+
+```text
+ AnalysisDomain
+       ^
+       |          | = has as a supertrait
+       |          . = provides a default impl for
+       |
+   Analysis
+     ^   ^
+     |   .
+     |   .
+     |   .
+ GenKillAnalysis
+
+```
+
+### Transfer Functions and Effects
+
+The dataflow framework in `rustc` allows each statement (and terminator) inside
+a basic block define its own transfer function. For brevity, these
+individual transfer functions are known as "effects". Each effect is applied
+successively in dataflow order, and together they define the transfer function
+for the entire basic block. It's also possible to define an effect for
+particular outgoing edges of some terminators (e.g.
+[`apply_call_return_effect`] for the `success` edge of a `Call`
+terminator). Collectively, these are referred to as "per-edge effects".
+
+The only meaningful difference (besides the "apply" prefix) between the methods
+of the `GenKillAnalysis` trait and the `Analysis` trait is that an `Analysis`
+has direct, mutable access to the dataflow state, whereas a `GenKillAnalysis`
+only sees an implementer of the `GenKill` trait, which only allows the `gen`
+and `kill` operations for mutation.
+
+### "Before" Effects
+
+Observant readers of the documentation may notice that there are actually *two*
+possible effects for each statement and terminator, the "before" effect and the
+unprefixed (or "primary") effect. The "before" effects are applied immediately
+before the unprefixed effect **regardless of the direction of the analysis**.
+In other words, a backward analysis will apply the "before" effect and then the
+"primary" effect when computing the transfer function for a basic block, just
+like a forward analysis.
+
+The vast majority of analyses should use only the unprefixed effects: Having
+multiple effects for each statement makes it difficult for consumers to know
+where they should be looking. However, the "before" variants can be useful in
+some scenarios, such as when the effect of the right-hand side of an assignment
+statement must be considered separately from the left-hand side.
+
+### Convergence
+
+Your analysis must converge to "fixpoint", otherwise it will run forever.
+Converging to fixpoint is just another way of saying "reaching equilibrium".
+In order to reach equilibrium, your analysis must obey some laws. One of the
+laws it must obey is that the bottom value[^bottom-purpose] joined with some
+other value equals the second value. Or, as an equation:
+
+> *bottom* join *x* = *x*
+
+Another law is that your analysis must have a "top value" such that
+
+> *top* join *x* = *top*
+
+Having a top value ensures that your semilattice has a finite height, and the
+law state above ensures that once the dataflow state reaches top, it will no
+longer change (the fixpoint will be top).
+
+[^bottom-purpose]: The bottom value's primary purpose is as the initial dataflow
+    state. Each basic block's entry state is initialized to bottom before the
+    analysis starts.
+
+## A Brief Example
+
+This section provides a brief example of a simple data-flow analysis at a high
+level. It doesn't explain everything you need to know, but hopefully it will
+make the rest of this page clearer.
+
+Let's say we want to do a simple analysis to find if `mem::transmute` may have
+been called by a certain point in the program. Our analysis domain will just
+be a `bool` that records whether `transmute` has been called so far. The bottom
+value will be `false`, since by default `transmute` has not been called. The top
+value will be `true`, since our analysis is done as soon as we determine that
+`transmute` has been called. Our join operator will just be the boolean OR (`||`)
+operator. We use OR and not AND because of this case:
+
+```
+let x = if some_cond {
+    std::mem::transmute<i32, u32>(0_i32); // transmute was called!
+} else {
+    1_u32; // transmute was not called
+};
+
+// Has transmute been called by this point? We conservatively approximate that
+// as yes, and that is why we use the OR operator.
+println!("x: {}", x);
+```
+
+## Inspecting the Results of a Dataflow Analysis
+
+Once you have constructed an analysis, you must pass it to an [`Engine`], which
+is responsible for finding the steady-state solution to your dataflow problem.
+You should use the [`into_engine`] method defined on the `Analysis` trait for
+this, since it will use the more efficient `Engine::new_gen_kill` constructor
+when possible.
+
+Calling `iterate_to_fixpoint` on your `Engine` will return a `Results`, which
+contains the dataflow state at fixpoint upon entry of each block. Once you have
+a `Results`, you can inspect the dataflow state at fixpoint at any point in
+the CFG. If you only need the state at a few locations (e.g., each `Drop`
+terminator) use a [`ResultsCursor`]. If you need the state at *every* location,
+a [`ResultsVisitor`] will be more efficient.
+
+```text
+                         Analysis
+                            |
+                            | into_engine(…)
+                            |
+                          Engine
+                            |
+                            | iterate_to_fixpoint()
+                            |
+                         Results
+                         /     \
+ into_results_cursor(…) /       \  visit_with(…)
+                       /         \
+               ResultsCursor  ResultsVisitor
+```
+
+For example, the following code uses a [`ResultsVisitor`]...
+
+
+```rust,ignore
+// Assuming `MyVisitor` implements `ResultsVisitor<FlowState = MyAnalysis::Domain>`...
+let mut my_visitor = MyVisitor::new();
+
+// inspect the fixpoint state for every location within every block in RPO.
+let results = MyAnalysis::new()
+    .into_engine(tcx, body, def_id)
+    .iterate_to_fixpoint()
+    .visit_in_rpo_with(body, &mut my_visitor);
+```
+
+whereas this code uses [`ResultsCursor`]:
+
+```rust,ignore
+let mut results = MyAnalysis::new()
+    .into_engine(tcx, body, def_id)
+    .iterate_to_fixpoint()
+    .into_results_cursor(body);
+
+// Inspect the fixpoint state immediately before each `Drop` terminator.
+for (bb, block) in body.basic_blocks().iter_enumerated() {
+    if let TerminatorKind::Drop { .. } = block.terminator().kind {
+        results.seek_before_primary_effect(body.terminator_loc(bb));
+        let state = results.get();
+        println!("state before drop: {:#?}", state);
+    }
+}
+```
+
+### Graphviz Diagrams
+
+When the results of a dataflow analysis are not what you expect, it often helps
+to visualize them. This can be done with the `-Z dump-mir` flags described in
+[Debugging MIR]. Start with `-Z dump-mir=F -Z dump-mir-dataflow`, where `F` is
+either "all" or the name of the MIR body you are interested in.
+
+These `.dot` files will be saved in your `mir_dump` directory and will have the
+[`NAME`] of the analysis (e.g. `maybe_inits`) as part of their filename. Each
+visualization will display the full dataflow state at entry and exit of each
+block, as well as any changes that occur in each statement and terminator.  See
+the example below:
+
+![A graphviz diagram for a dataflow analysis](../img/dataflow-graphviz-example.png)
+
+["gen-kill" problems]: https://en.wikipedia.org/wiki/Data-flow_analysis#Bit_vector_problems
+[*Static Program Analysis*]: https://cs.au.dk/~amoeller/spa/
+[Debugging MIR]: ./debugging.html
+[`AnalysisDomain`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.AnalysisDomain.html
+[`Analysis`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.Analysis.html
+[`Engine`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/struct.Engine.html
+[`GenKillAnalysis`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.GenKillAnalysis.html
+[`JoinSemiLattice`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/lattice/trait.JoinSemiLattice.html
+[`NAME`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.AnalysisDomain.html#associatedconstant.NAME
+[`ResultsCursor`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/struct.ResultsCursor.html
+[`ResultsVisitor`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.ResultsVisitor.html
+[`apply_call_return_effect`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.Analysis.html#tymethod.apply_call_return_effect
+[`into_engine`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/trait.Analysis.html#method.into_engine
+[`lattice`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/lattice/index.html
+[pr-1295]: https://github.com/rust-lang/rustc-dev-guide/pull/1295
+[pr-1295-comment]: https://github.com/rust-lang/rustc-dev-guide/pull/1295#issuecomment-1118131294
+[lattice]: https://en.wikipedia.org/wiki/Lattice_(order)
+[wiki]: https://en.wikipedia.org/wiki/Data-flow_analysis#Basic_principles
diff --git a/src/doc/rustc-dev-guide/src/mir/debugging.md b/src/doc/rustc-dev-guide/src/mir/debugging.md
new file mode 100644
index 000000000..3da17785b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/debugging.md
@@ -0,0 +1,98 @@
+# MIR Debugging
+
+The `-Z dump-mir` flag can be used to dump a text representation of the MIR.
+The following optional flags, used in combination with `-Z dump-mir`, enable
+additional output formats, including:
+
+* `-Z dump-mir-graphviz` - dumps a `.dot` file that represents MIR as a
+control-flow graph
+* `-Z dump-mir-dataflow` - dumps a `.dot` file showing the [dataflow state] at
+  each point in the control-flow graph
+* `-Z dump-mir-spanview` - dumps an `.html` file that highlights the source
+spans associated with MIR elements (including mouse-over actions to reveal
+elements obscured by overlaps, and tooltips to view the MIR statements).
+This flag takes an optional value: `statement` (the default), `terminator`, or
+`block`, to generate span highlights with different levels of granularity.
+
+`-Z dump-mir=F` is a handy compiler options that will let you view the MIR for
+each function at each stage of compilation. `-Z dump-mir` takes a **filter** `F`
+which allows you to control which functions and which passes you are
+interesting in. For example:
+
+```bash
+> rustc -Z dump-mir=foo ...
+```
+
+This will dump the MIR for any function whose name contains `foo`; it
+will dump the MIR both before and after every pass. Those files will
+be created in the `mir_dump` directory. There will likely be quite a
+lot of them!
+
+```bash
+> cat > foo.rs
+fn main() {
+    println!("Hello, world!");
+}
+^D
+> rustc -Z dump-mir=main foo.rs
+> ls mir_dump/* | wc -l
+     161
+```
+
+The files have names like `rustc.main.000-000.CleanEndRegions.after.mir`. These
+names have a number of parts:
+
+```text
+rustc.main.000-000.CleanEndRegions.after.mir
+      ---- --- --- --------------- ----- either before or after
+      |    |   |   name of the pass
+      |    |   index of dump within the pass (usually 0, but some passes dump intermediate states)
+      |    index of the pass
+      def-path to the function etc being dumped
+```
+
+You can also make more selective filters. For example, `main & CleanEndRegions`
+will select for things that reference *both* `main` and the pass
+`CleanEndRegions`:
+
+```bash
+> rustc -Z dump-mir='main & CleanEndRegions' foo.rs
+> ls mir_dump
+rustc.main.000-000.CleanEndRegions.after.mir	rustc.main.000-000.CleanEndRegions.before.mir
+```
+<!--- TODO: Change NoLandingPads. [#1232](https://github.com/rust-lang/rustc-dev-guide/issues/1232) -->
+Filters can also have `|` parts to combine multiple sets of
+`&`-filters. For example `main & CleanEndRegions | main &
+NoLandingPads` will select *either* `main` and `CleanEndRegions` *or*
+`main` and `NoLandingPads`:
+
+```bash
+> rustc -Z dump-mir='main & CleanEndRegions | main & NoLandingPads' foo.rs
+> ls mir_dump
+rustc.main-promoted[0].002-000.NoLandingPads.after.mir
+rustc.main-promoted[0].002-000.NoLandingPads.before.mir
+rustc.main-promoted[0].002-006.NoLandingPads.after.mir
+rustc.main-promoted[0].002-006.NoLandingPads.before.mir
+rustc.main-promoted[1].002-000.NoLandingPads.after.mir
+rustc.main-promoted[1].002-000.NoLandingPads.before.mir
+rustc.main-promoted[1].002-006.NoLandingPads.after.mir
+rustc.main-promoted[1].002-006.NoLandingPads.before.mir
+rustc.main.000-000.CleanEndRegions.after.mir
+rustc.main.000-000.CleanEndRegions.before.mir
+rustc.main.002-000.NoLandingPads.after.mir
+rustc.main.002-000.NoLandingPads.before.mir
+rustc.main.002-006.NoLandingPads.after.mir
+rustc.main.002-006.NoLandingPads.before.mir
+```
+
+(Here, the `main-promoted[0]` files refer to the MIR for "promoted constants"
+that appeared within the `main` function.)
+
+The `-Z unpretty=mir-cfg` flag can be used to create a graphviz MIR
+control-flow diagram for the whole crate:
+
+![A control-flow diagram](mir_cfg.svg)
+
+TODO: anything else?
+
+[dataflow state]: ./dataflow.html#graphviz-diagrams
diff --git a/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md b/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md
new file mode 100644
index 000000000..20b92cc45
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/drop-elaboration.md
@@ -0,0 +1,195 @@
+# Drop elaboration
+
+<!-- toc -->
+
+## Dynamic drops
+
+According to the [reference][reference-drop]:
+
+> When an initialized variable or temporary goes out of scope, its destructor
+> is run, or it is dropped. Assignment also runs the destructor of its
+> left-hand operand, if it's initialized. If a variable has been partially
+> initialized, only its initialized fields are dropped.
+
+When building the MIR, the `Drop` and `DropAndReplace` terminators represent
+places where drops may occur. However, in this phase, the presence of these
+terminators does not guarantee that a destructor will run. That's because the
+target of a drop may be uninitialized (usually because it has been moved from)
+before the terminator is reached. In general, we cannot know at compile-time whether a
+variable is initialized.
+
+```rust
+let mut y = vec![];
+
+{
+    let x = vec![1, 2, 3];
+    if std::process::id() % 2 == 0 {
+        y = x; // conditionally move `x` into `y`
+    }
+} // `x` goes out of scope here. Should it be dropped?
+```
+
+In these cases, we need to keep track of whether a variable is initialized
+*dynamically*. The rules are laid out in detail in [RFC 320: Non-zeroing
+dynamic drops][RFC 320].
+
+## Drop obligations
+
+From the RFC:
+
+> When a local variable becomes initialized, it establishes a set of "drop
+> obligations": a set of structural paths (e.g. a local `a`, or a path to a
+> field `b.f.y`) that need to be dropped.
+>
+> The drop obligations for a local variable x of struct-type `T` are computed
+> from analyzing the structure of `T`. If `T` itself implements `Drop`, then `x` is a
+> drop obligation. If `T` does not implement `Drop`, then the set of drop
+> obligations is the union of the drop obligations of the fields of `T`.
+
+When a structural path is moved from (and thus becomes uninitialized), any drop
+obligations for that path or its descendants (`path.f`, `path.f.g.h`, etc.) are
+released. Types with `Drop` implementations do not permit moves from individual
+fields, so there is no need to track initializedness through them.
+
+When a local variable goes out of scope (`Drop`), or when a structural path is
+overwritten via assignment (`DropAndReplace`), we check for any drop
+obligations for that variable or path.  Unless that obligation has been
+released by this point, its associated `Drop` implementation will be called.
+For `enum` types, only fields corresponding to the "active" variant need to be
+dropped. When processing drop obligations for such types, we first check the
+discriminant to determine the active variant. All drop obligations for variants
+besides the active one are ignored.
+
+Here are a few interesting types to help illustrate these rules:
+
+```rust
+struct NoDrop(u8); // No `Drop` impl. No fields with `Drop` impls.
+
+struct NeedsDrop(Vec<u8>); // No `Drop` impl but has fields with `Drop` impls.
+
+struct ThinVec(*const u8); // Custom `Drop` impl. Individual fields cannot be moved from.
+
+impl Drop for ThinVec {
+    fn drop(&mut self) { /* ... */ }
+}
+
+enum MaybeDrop {
+    Yes(NeedsDrop),
+    No(NoDrop),
+}
+```
+
+## Drop elaboration
+
+One valid model for these rules is to keep a boolean flag (a "drop flag") for
+every structural path that is used at any point in the function. This flag is
+set when its path is initialized and is cleared when the path is moved from.
+When a `Drop` occurs, we check the flags for every obligation associated with
+the target of the `Drop` and call the associated `Drop` impl for those that are
+still applicable.
+
+This process—transforming the newly built MIR with its imprecise `Drop` and
+`DropAndReplace` terminators into one with drop flags—is known as drop
+elaboration. When a MIR statement causes a variable to become initialized (or
+uninitialized), drop elaboration inserts code that sets (or clears) the drop
+flag for that variable. It wraps `Drop` terminators in conditionals that check
+the newly inserted drop flags.
+
+Drop elaboration also splits `DropAndReplace` terminators into a `Drop` of the
+target and a write of the newly dropped place. This is somewhat unrelated to what
+we've discussed above.
+
+Once this is complete, `Drop` terminators in the MIR correspond to a call to
+the "drop glue" or "drop shim" for the type of the dropped place. The drop
+glue for a type calls the `Drop` impl for that type (if one exists), and then
+recursively calls the drop glue for all fields of that type.
+
+## Drop elaboration in `rustc`
+
+The approach described above is more expensive than necessary. One can imagine
+a few optimizations:
+
+- Only paths that are the target of a `Drop` (or have the target as a prefix)
+  need drop flags.
+- Some variables are known to initialized (or uninitialized) when they are
+  dropped. These do not need drop flags.
+- If a set of paths are only dropped or moved from via a shared prefix, those
+  paths can share a single drop flag.
+
+A subset of these are implemented in `rustc`.
+
+In the compiler, drop elaboration is split across several modules. The pass
+itself is defined [here][drops-transform], but the [main logic][drops] is
+defined elsewhere since it is also used to build [drop shims][drops-shim].
+
+Drop elaboration designates each `Drop` in the newly built MIR as one of four
+kinds:
+
+- `Static`, the target is always initialized.
+- `Dead`, the target is always **un**initialized.
+- `Conditional`, the target is either wholly initialized or wholly
+  uninitialized. It is not partly initialized.
+- `Open`, the target may be partly initialized.
+
+For this, it uses a pair of dataflow analyses, `MaybeInitializedPlaces` and
+`MaybeUninitializedPlaces`. If a place is in one but not the other, then the
+initializedness of the target is known at compile-time (`Dead` or `Static`).
+In this case, drop elaboration does not add a flag for the target. It simply
+removes (`Dead`) or preserves (`Static`) the `Drop` terminator.
+
+For `Conditional` drops, we know that the initializedness of the variable as a
+whole is the same as the initializedness of its fields. Therefore, once we
+generate a drop flag for the target of that drop, it's safe to call the drop
+glue for that target.
+
+### `Open` drops
+
+`Open` drops are the most complex, since we need to break down a single `Drop`
+terminator into several different ones, one for each field of the target whose
+type has drop glue (`Ty::needs_drop`). We cannot call the drop glue for the
+target itself because that requires all fields of the target to be initialized.
+Remember, variables whose type has a custom `Drop` impl do not allow `Open`
+drops because their fields cannot be moved from.
+
+This is accomplished by recursively categorizing each field as `Dead`,
+`Static`, `Conditional` or `Open`. Fields whose type does not have drop glue
+are automatically `Dead` and need not be considered during the recursion. When
+we reach a field whose kind is not `Open`, we handle it as we did above. If the
+field is also `Open`, the recursion continues.
+
+It's worth noting how we handle `Open` drops of enums. Inside drop elaboration,
+each variant of the enum is treated like a field, with the invariant that only
+one of those "variant fields" can be initialized at any given time. In the
+general case, we do not know which variant is the active one, so we will have
+to call the drop glue for the enum (which checks the discriminant) or check the
+discriminant ourselves as part of an elaborated `Open` drop. However, in
+certain cases (within a `match` arm, for example) we do know which variant of
+an enum is active. This information is encoded in the `MaybeInitializedPlaces`
+and `MaybeUninitializedPlaces` dataflow analyses by marking all places
+corresponding to inactive variants as uninitialized.
+
+### Cleanup paths
+
+TODO: Discuss drop elaboration and unwinding.
+
+## Aside: drop elaboration and const-eval
+
+In Rust, functions that are eligible for evaluation at compile-time must be
+marked explicitly using the `const` keyword. This includes implementations  of
+the `Drop` trait, which may or may not be `const`. Code that is eligible for
+compile-time evaluation may only call `const` functions, so any calls to
+non-const `Drop` implementations in such code must be forbidden.
+
+A call to a `Drop` impl is encoded as a `Drop` terminator in the MIR. However,
+as we discussed above, a `Drop` terminator in newly built MIR does not
+necessarily result in a call to `Drop::drop`. The drop target may be
+uninitialized at that point. This means that checking for non-const `Drop`s on
+the newly built MIR can result in spurious errors. Instead, we wait until after
+drop elaboration runs, which eliminates `Dead` drops (ones where the target is
+known to be uninitialized) to run these checks.
+
+[RFC 320]: https://rust-lang.github.io/rfcs/0320-nonzeroing-dynamic-drop.html
+[reference-drop]: https://doc.rust-lang.org/reference/destructors.html
+[drops]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
+[drops-shim]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_transform/src/shim.rs
+[drops-transform]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
diff --git a/src/doc/rustc-dev-guide/src/mir/index.md b/src/doc/rustc-dev-guide/src/mir/index.md
new file mode 100644
index 000000000..0c00928c0
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/index.md
@@ -0,0 +1,280 @@
+# The MIR (Mid-level IR)
+
+<!-- toc -->
+
+MIR is Rust's _Mid-level Intermediate Representation_. It is
+constructed from [HIR](../hir.html). MIR was introduced in
+[RFC 1211]. It is a radically simplified form of Rust that is used for
+certain flow-sensitive safety checks – notably the borrow checker! –
+and also for optimization and code generation.
+
+If you'd like a very high-level introduction to MIR, as well as some
+of the compiler concepts that it relies on (such as control-flow
+graphs and desugaring), you may enjoy the
+[rust-lang blog post that introduced MIR][blog].
+
+[blog]: https://blog.rust-lang.org/2016/04/19/MIR.html
+
+## Introduction to MIR
+
+MIR is defined in the [`compiler/rustc_middle/src/mir/`][mir] module, but much of the code
+that manipulates it is found in [`compiler/rustc_mir_build`][mirmanip_build],
+[`compiler/rustc_mir_transform`][mirmanip_transform], and
+[`compiler/rustc_mir_dataflow`][mirmanip_dataflow].
+
+[RFC 1211]: https://rust-lang.github.io/rfcs/1211-mir.html
+
+Some of the key characteristics of MIR are:
+
+- It is based on a [control-flow graph][cfg].
+- It does not have nested expressions.
+- All types in MIR are fully explicit.
+
+[cfg]: ../appendix/background.html#cfg
+
+## Key MIR vocabulary
+
+This section introduces the key concepts of MIR, summarized here:
+
+- **Basic blocks**: units of the control-flow graph, consisting of:
+  - **statements:** actions with one successor
+  - **terminators:** actions with potentially multiple successors; always at
+    the end of a block
+  - (if you're not familiar with the term *basic block*, see the [background
+    chapter][cfg])
+- **Locals:** Memory locations allocated on the stack (conceptually, at
+  least), such as function arguments, local variables, and
+  temporaries. These are identified by an index, written with a
+  leading underscore, like `_1`. There is also a special "local"
+  (`_0`) allocated to store the return value.
+- **Places:** expressions that identify a location in memory, like `_1` or
+  `_1.f`.
+- **Rvalues:** expressions that produce a value. The "R" stands for
+  the fact that these are the "right-hand side" of an assignment.
+  - **Operands:** the arguments to an rvalue, which can either be a
+    constant (like `22`) or a place (like `_1`).
+
+You can get a feeling for how MIR is constructed by translating simple
+programs into MIR and reading the pretty printed output. In fact, the
+playground makes this easy, since it supplies a MIR button that will
+show you the MIR for your program. Try putting this program into play
+(or [clicking on this link][sample-play]), and then clicking the "MIR"
+button on the top:
+
+[sample-play]: https://play.rust-lang.org/?gist=30074856e62e74e91f06abd19bd72ece&version=stable
+
+```rust
+fn main() {
+    let mut vec = Vec::new();
+    vec.push(1);
+    vec.push(2);
+}
+```
+
+You should see something like:
+
+```mir
+// WARNING: This output format is intended for human consumers only
+// and is subject to change without notice. Knock yourself out.
+fn main() -> () {
+    ...
+}
+```
+
+This is the MIR format for the `main` function.
+
+**Variable declarations.** If we drill in a bit, we'll see it begins
+with a bunch of variable declarations. They look like this:
+
+```mir
+let mut _0: ();                      // return place
+let mut _1: std::vec::Vec<i32>;      // in scope 0 at src/main.rs:2:9: 2:16
+let mut _2: ();
+let mut _3: &mut std::vec::Vec<i32>;
+let mut _4: ();
+let mut _5: &mut std::vec::Vec<i32>;
+```
+
+You can see that variables in MIR don't have names, they have indices,
+like `_0` or `_1`.  We also intermingle the user's variables (e.g.,
+`_1`) with temporary values (e.g., `_2` or `_3`). You can tell apart
+user-defined variables because they have debuginfo associated to them (see below).
+
+**User variable debuginfo.** Below the variable declarations, we find the only
+hint that `_1` represents a user variable:
+```mir
+scope 1 {
+    debug vec => _1;                 // in scope 1 at src/main.rs:2:9: 2:16
+}
+```
+Each `debug <Name> => <Place>;` annotation describes a named user variable,
+and where (i.e. the place) a debugger can find the data of that variable.
+Here the mapping is trivial, but optimizations may complicate the place,
+or lead to multiple user variables sharing the same place.
+Additionally, closure captures are described using the same system, and so
+they're complicated even without optimizations, e.g.: `debug x => (*((*_1).0: &T));`.
+
+The "scope" blocks (e.g., `scope 1 { .. }`) describe the lexical structure of
+the source program (which names were in scope when), so any part of the program
+annotated with `// in scope 0` would be missing `vec`, if you were stepping
+through the code in a debugger, for example.
+
+**Basic blocks.** Reading further, we see our first **basic block** (naturally
+it may look slightly different when you view it, and I am ignoring some of the
+comments):
+
+```mir
+bb0: {
+    StorageLive(_1);
+    _1 = const <std::vec::Vec<T>>::new() -> bb2;
+}
+```
+
+A basic block is defined by a series of **statements** and a final
+**terminator**.  In this case, there is one statement:
+
+```mir
+StorageLive(_1);
+```
+
+This statement indicates that the variable `_1` is "live", meaning
+that it may be used later – this will persist until we encounter a
+`StorageDead(_1)` statement, which indicates that the variable `_1` is
+done being used. These "storage statements" are used by LLVM to
+allocate stack space.
+
+The **terminator** of the block `bb0` is the call to `Vec::new`:
+
+```mir
+_1 = const <std::vec::Vec<T>>::new() -> bb2;
+```
+
+Terminators are different from statements because they can have more
+than one successor – that is, control may flow to different
+places. Function calls like the call to `Vec::new` are always
+terminators because of the possibility of unwinding, although in the
+case of `Vec::new` we are able to see that indeed unwinding is not
+possible, and hence we list only one successor block, `bb2`.
+
+If we look ahead to `bb2`, we will see it looks like this:
+
+```mir
+bb2: {
+    StorageLive(_3);
+    _3 = &mut _1;
+    _2 = const <std::vec::Vec<T>>::push(move _3, const 1i32) -> [return: bb3, unwind: bb4];
+}
+```
+
+Here there are two statements: another `StorageLive`, introducing the `_3`
+temporary, and then an assignment:
+
+```mir
+_3 = &mut _1;
+```
+
+Assignments in general have the form:
+
+```text
+<Place> = <Rvalue>
+```
+
+A place is an expression like `_3`, `_3.f` or `*_3` – it denotes a
+location in memory.  An **Rvalue** is an expression that creates a
+value: in this case, the rvalue is a mutable borrow expression, which
+looks like `&mut <Place>`. So we can kind of define a grammar for
+rvalues like so:
+
+```text
+<Rvalue>  = & (mut)? <Place>
+          | <Operand> + <Operand>
+          | <Operand> - <Operand>
+          | ...
+
+<Operand> = Constant
+          | copy Place
+          | move Place
+```
+
+As you can see from this grammar, rvalues cannot be nested – they can
+only reference places and constants. Moreover, when you use a place,
+we indicate whether we are **copying it** (which requires that the
+place have a type `T` where `T: Copy`) or **moving it** (which works
+for a place of any type). So, for example, if we had the expression `x
+= a + b + c` in Rust, that would get compiled to two statements and a
+temporary:
+
+```mir
+TMP1 = a + b
+x = TMP1 + c
+```
+
+([Try it and see][play-abc], though you may want to do release mode to skip
+over the overflow checks.)
+
+[play-abc]: https://play.rust-lang.org/?gist=1751196d63b2a71f8208119e59d8a5b6&version=stable
+
+## MIR data types
+
+The MIR data types are defined in the [`compiler/rustc_middle/src/mir/`][mir]
+module.  Each of the key concepts mentioned in the previous section
+maps in a fairly straightforward way to a Rust type.
+
+The main MIR data type is [`Body`]. It contains the data for a single
+function (along with sub-instances of Mir for "promoted constants",
+but [you can read about those below](#promoted)).
+
+- **Basic blocks**: The basic blocks are stored in the field
+  [`Body::basic_blocks`][basicblocks]; this is a vector
+  of [`BasicBlockData`] structures. Nobody ever references a
+  basic block directly: instead, we pass around [`BasicBlock`]
+  values, which are [newtype'd] indices into this vector.
+- **Statements** are represented by the type [`Statement`].
+- **Terminators** are represented by the [`Terminator`].
+- **Locals** are represented by a [newtype'd] index type [`Local`].
+  The data for a local variable is found in the
+  [`Body::local_decls`][localdecls] vector). There is also a special constant
+  [`RETURN_PLACE`] identifying the special "local" representing the return value.
+- **Places** are identified by the enum [`Place`]. There are a few
+  variants:
+  - Local variables like `_1`
+  - Static variables `FOO`
+  - **Projections**, which are fields or other things that "project
+    out" from a base place. These are represented by the type
+    [`ProjectionElem`].  So e.g. the place `_1.f` is a projection,
+    with `f` being the "projection element" and `_1` being the base
+    path. `*_1` is also a projection, with the `*` being represented
+    by the [`ProjectionElem::Deref`] element.
+- **Rvalues** are represented by the enum [`Rvalue`].
+- **Operands** are represented by the enum [`Operand`].
+
+## Representing constants
+
+*to be written*
+
+<a name="promoted"></a>
+
+### Promoted constants
+
+See the const-eval WG's [docs on promotion](https://github.com/rust-lang/const-eval/blob/master/promotion.md).
+
+
+[mir]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/index.html
+[mirmanip_build]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/index.html
+[mirmanip_transform]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/index.html
+[mirmanip_dataflow]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/index.html
+[`Body`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html
+[newtype'd]: ../appendix/glossary.html#newtype
+[basicblocks]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.basic_blocks
+[`BasicBlock`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlock.html
+[`BasicBlockData`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BasicBlockData.html
+[`Statement`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Statement.html
+[`Terminator`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/terminator/struct.Terminator.html
+[`Local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Local.html
+[localdecls]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Body.html#structfield.local_decls
+[`RETURN_PLACE`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/constant.RETURN_PLACE.html
+[`Place`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.Place.html
+[`ProjectionElem`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.ProjectionElem.html
+[`ProjectionElem::Deref`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.ProjectionElem.html#variant.Deref
+[`Rvalue`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.Rvalue.html
+[`Operand`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/enum.Operand.html
diff --git a/src/doc/rustc-dev-guide/src/mir/mir_cfg.svg b/src/doc/rustc-dev-guide/src/mir/mir_cfg.svg
new file mode 100644
index 000000000..70705ec04
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/mir_cfg.svg
@@ -0,0 +1,270 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.43.0 (0)
+ -->
+<!-- Title: __crate__ Pages: 1 -->
+<svg width="675pt" height="1010pt"
+ viewBox="0.00 0.00 675.00 1010.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 1006)">
+<title>__crate__</title>
+<polygon fill="white" stroke="transparent" points="-4,4 -4,-1006 671,-1006 671,4 -4,4"/>
+<g id="clust1" class="cluster">
+<title>cluster_Mir_0_4</title>
+<polygon fill="none" stroke="black" points="8,-161 8,-994 286,-994 286,-161 8,-161"/>
+<text text-anchor="start" x="76.5" y="-978.8" font-family="Courier, monospace" font-size="14.00">fn main() &#45;&gt; ()</text>
+<text text-anchor="start" x="76.5" y="-963.8" font-family="Courier, monospace" font-size="14.00">let _1: i32;</text>
+<text text-anchor="start" x="76.5" y="-948.8" font-family="Courier, monospace" font-size="14.00">let mut _2: i32;</text>
+<text text-anchor="start" x="76.5" y="-933.8" font-family="Courier, monospace" font-size="14.00">let mut _3: bool;</text>
+<text text-anchor="start" x="76.5" y="-918.8" font-family="Courier, monospace" font-size="14.00">let mut _4: i32;</text>
+<text text-anchor="start" x="76.5" y="-903.8" font-family="Courier, monospace" font-size="14.00">let mut _5: i32;</text>
+<text text-anchor="start" x="76.5" y="-888.8" font-family="Courier, monospace" font-size="14.00">debug x =&gt; _1;</text>
+<text text-anchor="start" x="76.5" y="-873.8" font-family="Courier, monospace" font-size="14.00">debug y =&gt; _2;</text>
+</g>
+<g id="clust2" class="cluster">
+<title>cluster_Mir_0_3</title>
+<polygon fill="none" stroke="black" points="294,-8 294,-904 659,-904 659,-8 294,-8"/>
+<text text-anchor="start" x="406" y="-888.8" font-family="Courier, monospace" font-size="14.00">fn incr() &#45;&gt; i32</text>
+<text text-anchor="start" x="406" y="-873.8" font-family="Courier, monospace" font-size="14.00">let mut _1: i32;</text>
+<text text-anchor="start" x="406" y="-858.8" font-family="Courier, monospace" font-size="14.00">let mut _2: bool;</text>
+<text text-anchor="start" x="406" y="-843.8" font-family="Courier, monospace" font-size="14.00">let mut _3: bool;</text>
+<text text-anchor="start" x="406" y="-828.8" font-family="Courier, monospace" font-size="14.00">debug ret =&gt; _1;</text>
+</g>
+<!-- bb0__0_4 -->
+<g id="node1" class="node">
+<title>bb0__0_4</title>
+<polygon fill="gray" stroke="transparent" points="24,-832.5 24,-853.5 270,-853.5 270,-832.5 24,-832.5"/>
+<polygon fill="none" stroke="black" points="24,-832.5 24,-853.5 270,-853.5 270,-832.5 24,-832.5"/>
+<text text-anchor="start" x="142.5" y="-839.3" font-family="Courier, monospace" font-size="14.00">0</text>
+<polygon fill="none" stroke="black" points="24,-691.5 24,-832.5 270,-832.5 270,-691.5 24,-691.5"/>
+<text text-anchor="start" x="27" y="-818.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_1)</text>
+<text text-anchor="start" x="27" y="-803.3" font-family="Courier, monospace" font-size="14.00">_1 = const 5_i32</text>
+<text text-anchor="start" x="27" y="-788.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_2)</text>
+<text text-anchor="start" x="27" y="-773.3" font-family="Courier, monospace" font-size="14.00">_2 = const 3_i32</text>
+<text text-anchor="start" x="27" y="-758.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_3)</text>
+<text text-anchor="start" x="27" y="-743.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_4)</text>
+<text text-anchor="start" x="27" y="-728.3" font-family="Courier, monospace" font-size="14.00">_4 = _1</text>
+<text text-anchor="start" x="27" y="-713.3" font-family="Courier, monospace" font-size="14.00">_3 = Gt(move _4, const 3_i32)</text>
+<text text-anchor="start" x="27" y="-698.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_4)</text>
+<polygon fill="none" stroke="black" points="24,-670.5 24,-691.5 270,-691.5 270,-670.5 24,-670.5"/>
+<text text-anchor="start" x="27" y="-677.3" font-family="Courier, monospace" font-size="14.00">switchInt(move _3)</text>
+</g>
+<!-- bb1__0_4 -->
+<g id="node2" class="node">
+<title>bb1__0_4</title>
+<polygon fill="gray" stroke="transparent" points="25,-487 25,-508 164,-508 164,-487 25,-487"/>
+<polygon fill="none" stroke="black" points="25,-487 25,-508 164,-508 164,-487 25,-487"/>
+<text text-anchor="start" x="90" y="-493.8" font-family="Courier, monospace" font-size="14.00">1</text>
+<polygon fill="none" stroke="black" points="25,-451 25,-487 164,-487 164,-451 25,-451"/>
+<text text-anchor="start" x="28" y="-472.8" font-family="Courier, monospace" font-size="14.00">_2 = const 4_i32</text>
+<text text-anchor="start" x="28" y="-457.8" font-family="Courier, monospace" font-size="14.00">_0 = const ()</text>
+<polygon fill="none" stroke="black" points="25,-430 25,-451 164,-451 164,-430 25,-430"/>
+<text text-anchor="start" x="28" y="-436.8" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb0__0_4&#45;&gt;bb1__0_4 -->
+<g id="edge2" class="edge">
+<title>bb0__0_4&#45;&gt;bb1__0_4</title>
+<path fill="none" stroke="black" d="M101.84,-666.96C99.96,-660.97 98.31,-654.95 97,-649 87.75,-607.15 87.6,-558.45 89.42,-522.43"/>
+<polygon fill="black" stroke="black" points="92.93,-522.33 90.01,-512.15 85.94,-521.93 92.93,-522.33"/>
+<text text-anchor="middle" x="134.5" y="-637.8" font-family="Courier, monospace" font-size="14.00">otherwise</text>
+</g>
+<!-- bb2__0_4 -->
+<g id="node3" class="node">
+<title>bb2__0_4</title>
+<polygon fill="gray" stroke="transparent" points="129,-583 129,-604 259,-604 259,-583 129,-583"/>
+<polygon fill="none" stroke="black" points="129,-583 129,-604 259,-604 259,-583 129,-583"/>
+<text text-anchor="start" x="189.5" y="-589.8" font-family="Courier, monospace" font-size="14.00">2</text>
+<polygon fill="none" stroke="black" points="129,-562 129,-583 259,-583 259,-562 129,-562"/>
+<text text-anchor="start" x="132" y="-568.8" font-family="Courier, monospace" font-size="14.00">StorageLive(_5)</text>
+<polygon fill="none" stroke="black" points="129,-541 129,-562 259,-562 259,-541 129,-541"/>
+<text text-anchor="start" x="132" y="-547.8" font-family="Courier, monospace" font-size="14.00">_5 = incr()</text>
+</g>
+<!-- bb0__0_4&#45;&gt;bb2__0_4 -->
+<g id="edge1" class="edge">
+<title>bb0__0_4&#45;&gt;bb2__0_4</title>
+<path fill="none" stroke="black" d="M170.71,-666.93C174.93,-650.07 179.15,-633.24 182.81,-618.63"/>
+<polygon fill="black" stroke="black" points="186.21,-619.45 185.25,-608.9 179.42,-617.75 186.21,-619.45"/>
+<text text-anchor="middle" x="199" y="-637.8" font-family="Courier, monospace" font-size="14.00">false</text>
+</g>
+<!-- bb4__0_4 -->
+<g id="node5" class="node">
+<title>bb4__0_4</title>
+<polygon fill="gray" stroke="transparent" points="69,-244.5 69,-265.5 199,-265.5 199,-244.5 69,-244.5"/>
+<polygon fill="none" stroke="black" points="69,-244.5 69,-265.5 199,-265.5 199,-244.5 69,-244.5"/>
+<text text-anchor="start" x="129.5" y="-251.3" font-family="Courier, monospace" font-size="14.00">4</text>
+<polygon fill="none" stroke="black" points="69,-193.5 69,-244.5 199,-244.5 199,-193.5 69,-193.5"/>
+<text text-anchor="start" x="72" y="-230.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_3)</text>
+<text text-anchor="start" x="72" y="-215.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_2)</text>
+<text text-anchor="start" x="72" y="-200.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_1)</text>
+<polygon fill="none" stroke="black" points="69,-172.5 69,-193.5 199,-193.5 199,-172.5 69,-172.5"/>
+<text text-anchor="start" x="72" y="-179.3" font-family="Courier, monospace" font-size="14.00">return</text>
+</g>
+<!-- bb1__0_4&#45;&gt;bb4__0_4 -->
+<g id="edge3" class="edge">
+<title>bb1__0_4&#45;&gt;bb4__0_4</title>
+<path fill="none" stroke="black" d="M77.27,-425.86C75.51,-419.94 74,-413.88 73,-408 65.48,-363.75 59.43,-349.79 73,-307 76.04,-297.41 80.57,-287.97 85.82,-279.04"/>
+<polygon fill="black" stroke="black" points="88.94,-280.64 91.27,-270.31 83,-276.94 88.94,-280.64"/>
+</g>
+<!-- bb3__0_4 -->
+<g id="node4" class="node">
+<title>bb3__0_4</title>
+<polygon fill="gray" stroke="transparent" points="90,-382.5 90,-403.5 270,-403.5 270,-382.5 90,-382.5"/>
+<polygon fill="none" stroke="black" points="90,-382.5 90,-403.5 270,-403.5 270,-382.5 90,-382.5"/>
+<text text-anchor="start" x="175.5" y="-389.3" font-family="Courier, monospace" font-size="14.00">3</text>
+<polygon fill="none" stroke="black" points="90,-331.5 90,-382.5 270,-382.5 270,-331.5 90,-331.5"/>
+<text text-anchor="start" x="93" y="-368.3" font-family="Courier, monospace" font-size="14.00">_2 = Add(_2, move _5)</text>
+<text text-anchor="start" x="93" y="-353.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_5)</text>
+<text text-anchor="start" x="93" y="-338.3" font-family="Courier, monospace" font-size="14.00">_0 = const ()</text>
+<polygon fill="none" stroke="black" points="90,-310.5 90,-331.5 270,-331.5 270,-310.5 90,-310.5"/>
+<text text-anchor="start" x="93" y="-317.3" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb2__0_4&#45;&gt;bb3__0_4 -->
+<g id="edge4" class="edge">
+<title>bb2__0_4&#45;&gt;bb3__0_4</title>
+<path fill="none" stroke="black" d="M191.72,-537.22C189.61,-505.01 186.42,-456.42 183.9,-418.04"/>
+<polygon fill="black" stroke="black" points="187.39,-417.76 183.25,-408.01 180.41,-418.22 187.39,-417.76"/>
+<text text-anchor="middle" x="214" y="-465.3" font-family="Courier, monospace" font-size="14.00">return</text>
+</g>
+<!-- bb3__0_4&#45;&gt;bb4__0_4 -->
+<g id="edge5" class="edge">
+<title>bb3__0_4&#45;&gt;bb4__0_4</title>
+<path fill="none" stroke="black" d="M163.13,-306.63C160.19,-297.95 157.11,-288.84 154.1,-279.92"/>
+<polygon fill="black" stroke="black" points="157.39,-278.71 150.87,-270.36 150.75,-280.96 157.39,-278.71"/>
+</g>
+<!-- bb0__0_3 -->
+<g id="node6" class="node">
+<title>bb0__0_3</title>
+<polygon fill="gray" stroke="transparent" points="359,-787.5 359,-808.5 514,-808.5 514,-787.5 359,-787.5"/>
+<polygon fill="none" stroke="black" points="359,-787.5 359,-808.5 514,-808.5 514,-787.5 359,-787.5"/>
+<text text-anchor="start" x="432" y="-794.3" font-family="Courier, monospace" font-size="14.00">0</text>
+<polygon fill="none" stroke="black" points="359,-736.5 359,-787.5 514,-787.5 514,-736.5 359,-736.5"/>
+<text text-anchor="start" x="362" y="-773.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_1)</text>
+<text text-anchor="start" x="362" y="-758.3" font-family="Courier, monospace" font-size="14.00">StorageLive(_2)</text>
+<text text-anchor="start" x="362" y="-743.3" font-family="Courier, monospace" font-size="14.00">_2 = const true</text>
+<polygon fill="none" stroke="black" points="359,-715.5 359,-736.5 514,-736.5 514,-715.5 359,-715.5"/>
+<text text-anchor="start" x="362" y="-722.3" font-family="Courier, monospace" font-size="14.00">switchInt(move _2)</text>
+</g>
+<!-- bb1__0_3 -->
+<g id="node7" class="node">
+<title>bb1__0_3</title>
+<polygon fill="gray" stroke="transparent" points="311,-479 311,-500 450,-500 450,-479 311,-479"/>
+<polygon fill="none" stroke="black" points="311,-479 311,-500 450,-500 450,-479 311,-479"/>
+<text text-anchor="start" x="376" y="-485.8" font-family="Courier, monospace" font-size="14.00">1</text>
+<polygon fill="none" stroke="black" points="311,-458 311,-479 450,-479 450,-458 311,-458"/>
+<text text-anchor="start" x="314" y="-464.8" font-family="Courier, monospace" font-size="14.00">_1 = const 7_i32</text>
+<polygon fill="none" stroke="black" points="311,-437 311,-458 450,-458 450,-437 311,-437"/>
+<text text-anchor="start" x="314" y="-443.8" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb0__0_3&#45;&gt;bb1__0_3 -->
+<g id="edge7" class="edge">
+<title>bb0__0_3&#45;&gt;bb1__0_3</title>
+<path fill="none" stroke="black" d="M409.66,-711.9C400.78,-692.78 391.89,-670.39 387,-649 376.77,-604.3 376,-551.71 377.19,-515.15"/>
+<polygon fill="black" stroke="black" points="380.7,-514.94 377.59,-504.81 373.71,-514.67 380.7,-514.94"/>
+<text text-anchor="middle" x="424.5" y="-637.8" font-family="Courier, monospace" font-size="14.00">otherwise</text>
+</g>
+<!-- bb2__0_3 -->
+<g id="node8" class="node">
+<title>bb2__0_3</title>
+<polygon fill="gray" stroke="transparent" points="408,-591 408,-612 563,-612 563,-591 408,-591"/>
+<polygon fill="none" stroke="black" points="408,-591 408,-612 563,-612 563,-591 408,-591"/>
+<text text-anchor="start" x="481" y="-597.8" font-family="Courier, monospace" font-size="14.00">2</text>
+<polygon fill="none" stroke="black" points="408,-555 408,-591 563,-591 563,-555 408,-555"/>
+<text text-anchor="start" x="411" y="-576.8" font-family="Courier, monospace" font-size="14.00">StorageLive(_3)</text>
+<text text-anchor="start" x="411" y="-561.8" font-family="Courier, monospace" font-size="14.00">_3 = const true</text>
+<polygon fill="none" stroke="black" points="408,-534 408,-555 563,-555 563,-534 408,-534"/>
+<text text-anchor="start" x="411" y="-540.8" font-family="Courier, monospace" font-size="14.00">switchInt(move _3)</text>
+</g>
+<!-- bb0__0_3&#45;&gt;bb2__0_3 -->
+<g id="edge6" class="edge">
+<title>bb0__0_3&#45;&gt;bb2__0_3</title>
+<path fill="none" stroke="black" d="M449,-711.75C455.92,-685.29 464.41,-652.79 471.41,-626"/>
+<polygon fill="black" stroke="black" points="474.87,-626.6 474.01,-616.04 468.1,-624.83 474.87,-626.6"/>
+<text text-anchor="middle" x="490" y="-637.8" font-family="Courier, monospace" font-size="14.00">false</text>
+</g>
+<!-- bb6__0_3 -->
+<g id="node12" class="node">
+<title>bb6__0_3</title>
+<polygon fill="gray" stroke="transparent" points="311,-107 311,-128 524,-128 524,-107 311,-107"/>
+<polygon fill="none" stroke="black" points="311,-107 311,-128 524,-128 524,-107 311,-107"/>
+<text text-anchor="start" x="413" y="-113.8" font-family="Courier, monospace" font-size="14.00">6</text>
+<polygon fill="none" stroke="black" points="311,-41 311,-107 524,-107 524,-41 311,-41"/>
+<text text-anchor="start" x="314" y="-92.8" font-family="Courier, monospace" font-size="14.00">StorageDead(_2)</text>
+<text text-anchor="start" x="314" y="-77.8" font-family="Courier, monospace" font-size="14.00">_1 = Add(_1, const 1_i32)</text>
+<text text-anchor="start" x="314" y="-62.8" font-family="Courier, monospace" font-size="14.00">_0 = _1</text>
+<text text-anchor="start" x="314" y="-47.8" font-family="Courier, monospace" font-size="14.00">StorageDead(_1)</text>
+<polygon fill="none" stroke="black" points="311,-20 311,-41 524,-41 524,-20 311,-20"/>
+<text text-anchor="start" x="314" y="-26.8" font-family="Courier, monospace" font-size="14.00">return</text>
+</g>
+<!-- bb1__0_3&#45;&gt;bb6__0_3 -->
+<g id="edge8" class="edge">
+<title>bb1__0_3&#45;&gt;bb6__0_3</title>
+<path fill="none" stroke="black" d="M331.73,-433.35C324.52,-425.86 318.13,-417.35 314,-408 295.84,-366.95 310.8,-351.77 314,-307 318.68,-241.61 306.35,-219.97 335,-161 338.42,-153.95 342.63,-147.11 347.32,-140.55"/>
+<polygon fill="black" stroke="black" points="350.24,-142.5 353.5,-132.42 344.67,-138.27 350.24,-142.5"/>
+</g>
+<!-- bb3__0_3 -->
+<g id="node9" class="node">
+<title>bb3__0_3</title>
+<polygon fill="gray" stroke="transparent" points="331,-367.5 331,-388.5 470,-388.5 470,-367.5 331,-367.5"/>
+<polygon fill="none" stroke="black" points="331,-367.5 331,-388.5 470,-388.5 470,-367.5 331,-367.5"/>
+<text text-anchor="start" x="396" y="-374.3" font-family="Courier, monospace" font-size="14.00">3</text>
+<polygon fill="none" stroke="black" points="331,-346.5 331,-367.5 470,-367.5 470,-346.5 331,-346.5"/>
+<text text-anchor="start" x="334" y="-353.3" font-family="Courier, monospace" font-size="14.00">_1 = const 8_i32</text>
+<polygon fill="none" stroke="black" points="331,-325.5 331,-346.5 470,-346.5 470,-325.5 331,-325.5"/>
+<text text-anchor="start" x="334" y="-332.3" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb2__0_3&#45;&gt;bb3__0_3 -->
+<g id="edge10" class="edge">
+<title>bb2__0_3&#45;&gt;bb3__0_3</title>
+<path fill="none" stroke="black" d="M483.48,-529.9C480.99,-499.7 474.7,-458.73 459,-426 454.85,-417.34 449.27,-408.94 443.2,-401.17"/>
+<polygon fill="black" stroke="black" points="445.52,-398.49 436.45,-393 440.12,-402.94 445.52,-398.49"/>
+<text text-anchor="middle" x="518.5" y="-465.3" font-family="Courier, monospace" font-size="14.00">otherwise</text>
+</g>
+<!-- bb4__0_3 -->
+<g id="node10" class="node">
+<title>bb4__0_3</title>
+<polygon fill="gray" stroke="transparent" points="504,-367.5 504,-388.5 643,-388.5 643,-367.5 504,-367.5"/>
+<polygon fill="none" stroke="black" points="504,-367.5 504,-388.5 643,-388.5 643,-367.5 504,-367.5"/>
+<text text-anchor="start" x="569" y="-374.3" font-family="Courier, monospace" font-size="14.00">4</text>
+<polygon fill="none" stroke="black" points="504,-346.5 504,-367.5 643,-367.5 643,-346.5 504,-346.5"/>
+<text text-anchor="start" x="507" y="-353.3" font-family="Courier, monospace" font-size="14.00">_1 = const 9_i32</text>
+<polygon fill="none" stroke="black" points="504,-325.5 504,-346.5 643,-346.5 643,-325.5 504,-325.5"/>
+<text text-anchor="start" x="507" y="-332.3" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb2__0_3&#45;&gt;bb4__0_3 -->
+<g id="edge9" class="edge">
+<title>bb2__0_3&#45;&gt;bb4__0_3</title>
+<path fill="none" stroke="black" d="M544.42,-529.7C549.29,-524.24 553.63,-518.32 557,-512 574.81,-478.61 577.84,-435.35 576.97,-403.27"/>
+<polygon fill="black" stroke="black" points="580.47,-403.12 576.57,-393.27 573.48,-403.41 580.47,-403.12"/>
+<text text-anchor="middle" x="597" y="-465.3" font-family="Courier, monospace" font-size="14.00">false</text>
+</g>
+<!-- bb5__0_3 -->
+<g id="node11" class="node">
+<title>bb5__0_3</title>
+<polygon fill="gray" stroke="transparent" points="352,-229.5 352,-250.5 482,-250.5 482,-229.5 352,-229.5"/>
+<polygon fill="none" stroke="black" points="352,-229.5 352,-250.5 482,-250.5 482,-229.5 352,-229.5"/>
+<text text-anchor="start" x="412.5" y="-236.3" font-family="Courier, monospace" font-size="14.00">5</text>
+<polygon fill="none" stroke="black" points="352,-208.5 352,-229.5 482,-229.5 482,-208.5 352,-208.5"/>
+<text text-anchor="start" x="355" y="-215.3" font-family="Courier, monospace" font-size="14.00">StorageDead(_3)</text>
+<polygon fill="none" stroke="black" points="352,-187.5 352,-208.5 482,-208.5 482,-187.5 352,-187.5"/>
+<text text-anchor="start" x="355" y="-194.3" font-family="Courier, monospace" font-size="14.00">goto</text>
+</g>
+<!-- bb3__0_3&#45;&gt;bb5__0_3 -->
+<g id="edge11" class="edge">
+<title>bb3__0_3&#45;&gt;bb5__0_3</title>
+<path fill="none" stroke="black" d="M404.33,-321.83C406.49,-304.57 409.13,-283.49 411.43,-265.05"/>
+<polygon fill="black" stroke="black" points="414.91,-265.46 412.67,-255.11 407.96,-264.6 414.91,-265.46"/>
+</g>
+<!-- bb4__0_3&#45;&gt;bb5__0_3 -->
+<g id="edge12" class="edge">
+<title>bb4__0_3&#45;&gt;bb5__0_3</title>
+<path fill="none" stroke="black" d="M533.23,-321.83C512.24,-303.53 486.33,-280.94 464.31,-261.74"/>
+<polygon fill="black" stroke="black" points="466.53,-259.04 456.7,-255.11 461.93,-264.32 466.53,-259.04"/>
+</g>
+<!-- bb5__0_3&#45;&gt;bb6__0_3 -->
+<g id="edge13" class="edge">
+<title>bb5__0_3&#45;&gt;bb6__0_3</title>
+<path fill="none" stroke="black" d="M417,-183.76C417,-171.28 417,-156.74 417,-142.43"/>
+<polygon fill="black" stroke="black" points="420.5,-142.09 417,-132.09 413.5,-142.09 420.5,-142.09"/>
+</g>
+</g>
+</svg>
diff --git a/src/doc/rustc-dev-guide/src/mir/mir_detailed.dot b/src/doc/rustc-dev-guide/src/mir/mir_detailed.dot
new file mode 100644
index 000000000..1494f4f0b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/mir_detailed.dot
@@ -0,0 +1,27 @@
+digraph G {
+    Operand -> Constant
+    Operand -> Place [taillabel="read"]
+    Place -> Projection
+    Projection -> Place
+    Place -> LocalId
+    Rvalue -> "Rvalue\nAggregate"
+    Rvalue -> "Rvalue\nBinaryOp"
+    Rvalue -> "Rvalue\nUnaryOp"
+    Rvalue -> "Rvalue\n..."
+    "Rvalue\nAggregate" -> Operand [headlabel="*"]
+    "Rvalue\nBinaryOp" -> Operand [headlabel="2"]
+    "Rvalue\nUnaryOp" -> Operand
+    "Statement\nAssignment" -> Place [taillabel="write"]
+    "Statement\nAssignment" -> Rvalue
+    Statement -> "Statement\nAssignment"
+    Statement -> "Statement\n..."
+    Block -> Statement [headlabel="*"]
+    Block -> Terminator
+    Terminator -> "Terminator\nSwitchInt"
+    "Terminator\nSwitchInt" -> Operand
+    "Terminator\nSwitchInt" -> Constant [headlabel="*"]
+    "Terminator\nSwitchInt" -> BlockId [headlabel="*"]
+    Terminator -> "Terminator\n..."
+    Mir -> Block [headlabel="*"]
+    Mir -> Local [headlabel="*"]
+}
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/mir/mir_detailed.svg b/src/doc/rustc-dev-guide/src/mir/mir_detailed.svg
new file mode 100644
index 000000000..771e9e5dc
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/mir_detailed.svg
@@ -0,0 +1,300 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.40.1 (20161225.0304)
+ -->
+<!-- Title: G Pages: 1 -->
+<svg width="710pt" height="655pt"
+ viewBox="0.00 0.00 710.21 655.48" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 651.4802)">
+<title>G</title>
+<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-651.4802 706.2058,-651.4802 706.2058,4 -4,4"/>
+<!-- Operand -->
+<g id="node1" class="node">
+<title>Operand</title>
+<ellipse fill="none" stroke="#000000" cx="235.0515" cy="-162" rx="40.8928" ry="18"/>
+<text text-anchor="middle" x="235.0515" y="-158.3" font-family="Times,serif" font-size="14.00" fill="#000000">Operand</text>
+</g>
+<!-- Constant -->
+<g id="node2" class="node">
+<title>Constant</title>
+<ellipse fill="none" stroke="#000000" cx="307.0515" cy="-90" rx="42.4939" ry="18"/>
+<text text-anchor="middle" x="307.0515" y="-86.3" font-family="Times,serif" font-size="14.00" fill="#000000">Constant</text>
+</g>
+<!-- Operand&#45;&gt;Constant -->
+<g id="edge1" class="edge">
+<title>Operand&#45;&gt;Constant</title>
+<path fill="none" stroke="#000000" d="M251.7507,-145.3008C261.1107,-135.9408 272.942,-124.1095 283.2569,-113.7945"/>
+<polygon fill="#000000" stroke="#000000" points="285.8466,-116.1546 290.4428,-106.6087 280.8969,-111.2049 285.8466,-116.1546"/>
+</g>
+<!-- Place -->
+<g id="node3" class="node">
+<title>Place</title>
+<ellipse fill="none" stroke="#000000" cx="163.0515" cy="-90" rx="29.795" ry="18"/>
+<text text-anchor="middle" x="163.0515" y="-86.3" font-family="Times,serif" font-size="14.00" fill="#000000">Place</text>
+</g>
+<!-- Operand&#45;&gt;Place -->
+<g id="edge2" class="edge">
+<title>Operand&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M218.3523,-145.3008C208.7249,-135.6734 196.4829,-123.4314 185.9657,-112.9142"/>
+<polygon fill="#000000" stroke="#000000" points="188.2204,-110.2191 178.6744,-105.6229 183.2706,-115.1689 188.2204,-110.2191"/>
+<text text-anchor="middle" x="206.3523" y="-134.1008" font-family="Times,serif" font-size="14.00" fill="#000000">read</text>
+</g>
+<!-- Projection -->
+<g id="node4" class="node">
+<title>Projection</title>
+<ellipse fill="none" stroke="#000000" cx="163.0515" cy="-18" rx="46.5926" ry="18"/>
+<text text-anchor="middle" x="163.0515" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">Projection</text>
+</g>
+<!-- Place&#45;&gt;Projection -->
+<g id="edge3" class="edge">
+<title>Place&#45;&gt;Projection</title>
+<path fill="none" stroke="#000000" d="M157.1358,-72.2022C156.3519,-64.3864 156.1204,-55.0171 156.4412,-46.2836"/>
+<polygon fill="#000000" stroke="#000000" points="159.9475,-46.2999 157.1065,-36.0931 152.9624,-45.8439 159.9475,-46.2999"/>
+</g>
+<!-- LocalId -->
+<g id="node5" class="node">
+<title>LocalId</title>
+<ellipse fill="none" stroke="#000000" cx="266.0515" cy="-18" rx="38.1938" ry="18"/>
+<text text-anchor="middle" x="266.0515" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">LocalId</text>
+</g>
+<!-- Place&#45;&gt;LocalId -->
+<g id="edge5" class="edge">
+<title>Place&#45;&gt;LocalId</title>
+<path fill="none" stroke="#000000" d="M182.9109,-76.1177C197.9447,-65.6086 218.8518,-50.994 235.939,-39.0495"/>
+<polygon fill="#000000" stroke="#000000" points="238.2842,-41.6805 244.475,-33.0826 234.2737,-35.9433 238.2842,-41.6805"/>
+</g>
+<!-- Projection&#45;&gt;Place -->
+<g id="edge4" class="edge">
+<title>Projection&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M168.9965,-36.0931C169.7664,-43.9477 169.9841,-53.3282 169.6494,-62.0453"/>
+<polygon fill="#000000" stroke="#000000" points="166.1453,-61.9901 168.9672,-72.2022 173.1296,-62.4593 166.1453,-61.9901"/>
+</g>
+<!-- Rvalue -->
+<g id="node6" class="node">
+<title>Rvalue</title>
+<ellipse fill="none" stroke="#000000" cx="204.0515" cy="-323.7401" rx="35.9954" ry="18"/>
+<text text-anchor="middle" x="204.0515" y="-320.0401" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+</g>
+<!-- Rvalue\nAggregate -->
+<g id="node7" class="node">
+<title>Rvalue\nAggregate</title>
+<ellipse fill="none" stroke="#000000" cx="69.0515" cy="-242.8701" rx="51.7379" ry="26.7407"/>
+<text text-anchor="middle" x="69.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+<text text-anchor="middle" x="69.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Aggregate</text>
+</g>
+<!-- Rvalue&#45;&gt;Rvalue\nAggregate -->
+<g id="edge6" class="edge">
+<title>Rvalue&#45;&gt;Rvalue\nAggregate</title>
+<path fill="none" stroke="#000000" d="M180.8442,-309.8381C161.9431,-298.5156 134.7462,-282.2237 111.9105,-268.5442"/>
+<polygon fill="#000000" stroke="#000000" points="113.454,-265.3889 103.0768,-263.2525 109.8568,-271.3939 113.454,-265.3889"/>
+</g>
+<!-- Rvalue\nBinaryOp -->
+<g id="node8" class="node">
+<title>Rvalue\nBinaryOp</title>
+<ellipse fill="none" stroke="#000000" cx="188.0515" cy="-242.8701" rx="49.4949" ry="26.7407"/>
+<text text-anchor="middle" x="188.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+<text text-anchor="middle" x="188.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">BinaryOp</text>
+</g>
+<!-- Rvalue&#45;&gt;Rvalue\nBinaryOp -->
+<g id="edge7" class="edge">
+<title>Rvalue&#45;&gt;Rvalue\nBinaryOp</title>
+<path fill="none" stroke="#000000" d="M200.5006,-305.7924C198.9755,-298.0839 197.134,-288.7767 195.3406,-279.7121"/>
+<polygon fill="#000000" stroke="#000000" points="198.73,-278.8098 193.3556,-269.6793 191.8631,-280.1684 198.73,-278.8098"/>
+</g>
+<!-- Rvalue\nUnaryOp -->
+<g id="node9" class="node">
+<title>Rvalue\nUnaryOp</title>
+<ellipse fill="none" stroke="#000000" cx="303.0515" cy="-242.8701" rx="47.2526" ry="26.7407"/>
+<text text-anchor="middle" x="303.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+<text text-anchor="middle" x="303.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">UnaryOp</text>
+</g>
+<!-- Rvalue&#45;&gt;Rvalue\nUnaryOp -->
+<g id="edge8" class="edge">
+<title>Rvalue&#45;&gt;Rvalue\nUnaryOp</title>
+<path fill="none" stroke="#000000" d="M223.1397,-308.1476C235.7504,-297.8463 252.6606,-284.0328 267.6777,-271.7658"/>
+<polygon fill="#000000" stroke="#000000" points="270.2561,-274.179 275.7864,-265.142 265.8276,-268.7578 270.2561,-274.179"/>
+</g>
+<!-- Rvalue\n... -->
+<g id="node10" class="node">
+<title>Rvalue\n...</title>
+<ellipse fill="none" stroke="#000000" cx="407.0515" cy="-242.8701" rx="38.7821" ry="26.7407"/>
+<text text-anchor="middle" x="407.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+<text text-anchor="middle" x="407.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">...</text>
+</g>
+<!-- Rvalue&#45;&gt;Rvalue\n... -->
+<g id="edge9" class="edge">
+<title>Rvalue&#45;&gt;Rvalue\n...</title>
+<path fill="none" stroke="#000000" d="M235.256,-314.6368C267.0067,-304.9668 317.3424,-288.5057 359.0515,-269.7401 362.195,-268.3258 365.4063,-266.7762 368.6037,-265.1575"/>
+<polygon fill="#000000" stroke="#000000" points="370.2926,-268.2238 377.5103,-260.4678 367.0313,-262.0299 370.2926,-268.2238"/>
+</g>
+<!-- Rvalue\nAggregate&#45;&gt;Operand -->
+<g id="edge10" class="edge">
+<title>Rvalue\nAggregate&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M107.1352,-224.3168C134.5352,-210.9684 171.2807,-193.0672 198.3573,-179.8763"/>
+<polygon fill="#000000" stroke="#000000" points="200.0432,-182.9483 207.5003,-175.4221 196.9774,-176.6553 200.0432,-182.9483"/>
+<text text-anchor="middle" x="204.0003" y="-179.2221" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+<!-- Rvalue\nBinaryOp&#45;&gt;Operand -->
+<g id="edge11" class="edge">
+<title>Rvalue\nBinaryOp&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M203.1813,-216.8371C208.4947,-207.6947 214.4647,-197.4225 219.7889,-188.2614"/>
+<polygon fill="#000000" stroke="#000000" points="222.8508,-189.9584 224.8496,-179.5538 216.7986,-186.441 222.8508,-189.9584"/>
+<text text-anchor="middle" x="221.3496" y="-183.3538" font-family="Times,serif" font-size="14.00" fill="#000000">2</text>
+</g>
+<!-- Rvalue\nUnaryOp&#45;&gt;Operand -->
+<g id="edge12" class="edge">
+<title>Rvalue\nUnaryOp&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M282.6492,-218.6064C274.253,-208.621 264.5321,-197.0602 256.0725,-186.9996"/>
+<polygon fill="#000000" stroke="#000000" points="258.7225,-184.7128 249.6079,-179.3114 253.3648,-189.2178 258.7225,-184.7128"/>
+</g>
+<!-- Statement\nAssignment -->
+<g id="node11" class="node">
+<title>Statement\nAssignment</title>
+<ellipse fill="none" stroke="#000000" cx="204.0515" cy="-404.6102" rx="57.9655" ry="26.7407"/>
+<text text-anchor="middle" x="204.0515" y="-408.4102" font-family="Times,serif" font-size="14.00" fill="#000000">Statement</text>
+<text text-anchor="middle" x="204.0515" y="-393.4102" font-family="Times,serif" font-size="14.00" fill="#000000">Assignment</text>
+</g>
+<!-- Statement\nAssignment&#45;&gt;Place -->
+<g id="edge13" class="edge">
+<title>Statement\nAssignment&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M158.0853,-387.9226C110.712,-367.9515 39.4797,-329.5163 8.0515,-269.7401 -28.3835,-200.4412 74.6545,-134.9955 130.1983,-105.8591"/>
+<polygon fill="#000000" stroke="#000000" points="132.0277,-108.8542 139.3251,-101.1732 128.8305,-102.627 132.0277,-108.8542"/>
+<text text-anchor="middle" x="144.0853" y="-376.7226" font-family="Times,serif" font-size="14.00" fill="#000000">write</text>
+</g>
+<!-- Statement\nAssignment&#45;&gt;Rvalue -->
+<g id="edge14" class="edge">
+<title>Statement\nAssignment&#45;&gt;Rvalue</title>
+<path fill="none" stroke="#000000" d="M204.0515,-377.6816C204.0515,-369.4111 204.0515,-360.2888 204.0515,-351.9358"/>
+<polygon fill="#000000" stroke="#000000" points="207.5516,-351.8889 204.0515,-341.8889 200.5516,-351.889 207.5516,-351.8889"/>
+</g>
+<!-- Statement -->
+<g id="node12" class="node">
+<title>Statement</title>
+<ellipse fill="none" stroke="#000000" cx="346.0515" cy="-485.4802" rx="46.2923" ry="18"/>
+<text text-anchor="middle" x="346.0515" y="-481.7802" font-family="Times,serif" font-size="14.00" fill="#000000">Statement</text>
+</g>
+<!-- Statement&#45;&gt;Statement\nAssignment -->
+<g id="edge15" class="edge">
+<title>Statement&#45;&gt;Statement\nAssignment</title>
+<path fill="none" stroke="#000000" d="M319.6752,-470.4587C300.0617,-459.2887 272.808,-443.7675 249.6863,-430.5996"/>
+<polygon fill="#000000" stroke="#000000" points="251.1463,-427.4033 240.7246,-425.4958 247.6821,-433.486 251.1463,-427.4033"/>
+</g>
+<!-- Statement\n... -->
+<g id="node13" class="node">
+<title>Statement\n...</title>
+<ellipse fill="none" stroke="#000000" cx="346.0515" cy="-404.6102" rx="50.41" ry="26.7407"/>
+<text text-anchor="middle" x="346.0515" y="-408.4102" font-family="Times,serif" font-size="14.00" fill="#000000">Statement</text>
+<text text-anchor="middle" x="346.0515" y="-393.4102" font-family="Times,serif" font-size="14.00" fill="#000000">...</text>
+</g>
+<!-- Statement&#45;&gt;Statement\n... -->
+<g id="edge16" class="edge">
+<title>Statement&#45;&gt;Statement\n...</title>
+<path fill="none" stroke="#000000" d="M346.0515,-467.1296C346.0515,-459.5597 346.0515,-450.5002 346.0515,-441.6583"/>
+<polygon fill="#000000" stroke="#000000" points="349.5516,-441.4808 346.0515,-431.4808 342.5516,-441.4808 349.5516,-441.4808"/>
+</g>
+<!-- Block -->
+<g id="node14" class="node">
+<title>Block</title>
+<ellipse fill="none" stroke="#000000" cx="385.0515" cy="-557.4802" rx="31.6951" ry="18"/>
+<text text-anchor="middle" x="385.0515" y="-553.7802" font-family="Times,serif" font-size="14.00" fill="#000000">Block</text>
+</g>
+<!-- Block&#45;&gt;Statement -->
+<g id="edge17" class="edge">
+<title>Block&#45;&gt;Statement</title>
+<path fill="none" stroke="#000000" d="M375.6107,-540.051C371.0795,-531.6857 365.5504,-521.4782 360.5052,-512.1641"/>
+<polygon fill="#000000" stroke="#000000" points="363.5167,-510.375 355.6763,-503.2491 357.3617,-513.7091 363.5167,-510.375"/>
+<text text-anchor="middle" x="352.1763" y="-507.0491" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+<!-- Terminator -->
+<g id="node15" class="node">
+<title>Terminator</title>
+<ellipse fill="none" stroke="#000000" cx="519.0515" cy="-323.7401" rx="50.8918" ry="18"/>
+<text text-anchor="middle" x="519.0515" y="-320.0401" font-family="Times,serif" font-size="14.00" fill="#000000">Terminator</text>
+</g>
+<!-- Block&#45;&gt;Terminator -->
+<g id="edge18" class="edge">
+<title>Block&#45;&gt;Terminator</title>
+<path fill="none" stroke="#000000" d="M394.9048,-540.2928C418.0234,-499.9664 475.8876,-399.0322 503.6797,-350.5535"/>
+<polygon fill="#000000" stroke="#000000" points="506.8808,-352.0069 508.818,-341.5907 500.808,-348.5254 506.8808,-352.0069"/>
+</g>
+<!-- Terminator\nSwitchInt -->
+<g id="node16" class="node">
+<title>Terminator\nSwitchInt</title>
+<ellipse fill="none" stroke="#000000" cx="519.0515" cy="-242.8701" rx="55.3091" ry="26.7407"/>
+<text text-anchor="middle" x="519.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Terminator</text>
+<text text-anchor="middle" x="519.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">SwitchInt</text>
+</g>
+<!-- Terminator&#45;&gt;Terminator\nSwitchInt -->
+<g id="edge19" class="edge">
+<title>Terminator&#45;&gt;Terminator\nSwitchInt</title>
+<path fill="none" stroke="#000000" d="M519.0515,-305.3894C519.0515,-297.8196 519.0515,-288.7601 519.0515,-279.9182"/>
+<polygon fill="#000000" stroke="#000000" points="522.5516,-279.7406 519.0515,-269.7407 515.5516,-279.7407 522.5516,-279.7406"/>
+</g>
+<!-- Terminator\n... -->
+<g id="node18" class="node">
+<title>Terminator\n...</title>
+<ellipse fill="none" stroke="#000000" cx="647.0515" cy="-242.8701" rx="55.3091" ry="26.7407"/>
+<text text-anchor="middle" x="647.0515" y="-246.6701" font-family="Times,serif" font-size="14.00" fill="#000000">Terminator</text>
+<text text-anchor="middle" x="647.0515" y="-231.6701" font-family="Times,serif" font-size="14.00" fill="#000000">...</text>
+</g>
+<!-- Terminator&#45;&gt;Terminator\n... -->
+<g id="edge23" class="edge">
+<title>Terminator&#45;&gt;Terminator\n...</title>
+<path fill="none" stroke="#000000" d="M544.035,-307.9556C561.1466,-297.1446 584.2754,-282.5318 604.2825,-269.8914"/>
+<polygon fill="#000000" stroke="#000000" points="606.3452,-272.7283 612.9298,-264.4281 602.6063,-266.8104 606.3452,-272.7283"/>
+</g>
+<!-- Terminator\nSwitchInt&#45;&gt;Operand -->
+<g id="edge20" class="edge">
+<title>Terminator\nSwitchInt&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M478.0996,-224.5602C470.5153,-221.4896 462.6034,-218.4951 455.0515,-216 396.6759,-196.7135 327.5597,-180.8457 282.5872,-171.4129"/>
+<polygon fill="#000000" stroke="#000000" points="283.0363,-167.9317 272.5338,-169.3272 281.6143,-174.7857 283.0363,-167.9317"/>
+</g>
+<!-- Terminator\nSwitchInt&#45;&gt;Constant -->
+<g id="edge21" class="edge">
+<title>Terminator\nSwitchInt&#45;&gt;Constant</title>
+<path fill="none" stroke="#000000" d="M487.7702,-220.3136C447.2089,-191.0654 376.9492,-140.4022 337.034,-111.6199"/>
+<polygon fill="#000000" stroke="#000000" points="338.9197,-108.6647 328.7614,-105.6547 334.8255,-114.3425 338.9197,-108.6647"/>
+<text text-anchor="middle" x="325.2614" y="-109.4547" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+<!-- BlockId -->
+<g id="node17" class="node">
+<title>BlockId</title>
+<ellipse fill="none" stroke="#000000" cx="519.0515" cy="-162" rx="38.9931" ry="18"/>
+<text text-anchor="middle" x="519.0515" y="-158.3" font-family="Times,serif" font-size="14.00" fill="#000000">BlockId</text>
+</g>
+<!-- Terminator\nSwitchInt&#45;&gt;BlockId -->
+<g id="edge22" class="edge">
+<title>Terminator\nSwitchInt&#45;&gt;BlockId</title>
+<path fill="none" stroke="#000000" d="M519.0515,-215.9415C519.0515,-207.6709 519.0515,-198.5487 519.0515,-190.1957"/>
+<polygon fill="#000000" stroke="#000000" points="522.5516,-190.1488 519.0515,-180.1488 515.5516,-190.1489 522.5516,-190.1488"/>
+<text text-anchor="middle" x="515.5515" y="-183.9488" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+<!-- Mir -->
+<g id="node19" class="node">
+<title>Mir</title>
+<ellipse fill="none" stroke="#000000" cx="425.0515" cy="-629.4802" rx="27" ry="18"/>
+<text text-anchor="middle" x="425.0515" y="-625.7802" font-family="Times,serif" font-size="14.00" fill="#000000">Mir</text>
+</g>
+<!-- Mir&#45;&gt;Block -->
+<g id="edge24" class="edge">
+<title>Mir&#45;&gt;Block</title>
+<path fill="none" stroke="#000000" d="M415.572,-612.4172C410.81,-603.8456 404.9356,-593.2716 399.6162,-583.6968"/>
+<polygon fill="#000000" stroke="#000000" points="402.6568,-581.9627 394.7408,-574.9209 396.5377,-585.3623 402.6568,-581.9627"/>
+<text text-anchor="middle" x="391.2408" y="-578.7209" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+<!-- Local -->
+<g id="node20" class="node">
+<title>Local</title>
+<ellipse fill="none" stroke="#000000" cx="465.0515" cy="-557.4802" rx="30.5947" ry="18"/>
+<text text-anchor="middle" x="465.0515" y="-553.7802" font-family="Times,serif" font-size="14.00" fill="#000000">Local</text>
+</g>
+<!-- Mir&#45;&gt;Local -->
+<g id="edge25" class="edge">
+<title>Mir&#45;&gt;Local</title>
+<path fill="none" stroke="#000000" d="M434.5309,-612.4172C439.293,-603.8456 445.1674,-593.2716 450.4867,-583.6968"/>
+<polygon fill="#000000" stroke="#000000" points="453.5653,-585.3623 455.3622,-574.9209 447.4462,-581.9627 453.5653,-585.3623"/>
+<text text-anchor="middle" x="451.8622" y="-578.7209" font-family="Times,serif" font-size="14.00" fill="#000000">*</text>
+</g>
+</g>
+</svg>
diff --git a/src/doc/rustc-dev-guide/src/mir/mir_overview.dot b/src/doc/rustc-dev-guide/src/mir/mir_overview.dot
new file mode 100644
index 000000000..c0b51674d
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/mir_overview.dot
@@ -0,0 +1,10 @@
+digraph G {
+    Operand -> Constant
+    Operand -> Place
+    Place -> Projection
+    Projection -> Place
+    Place -> Local
+    Rvalue -> Operand
+    Assignment -> Place
+    Assignment -> Operand
+}
\ No newline at end of file
diff --git a/src/doc/rustc-dev-guide/src/mir/mir_overview.svg b/src/doc/rustc-dev-guide/src/mir/mir_overview.svg
new file mode 100644
index 000000000..b8f092cd2
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/mir_overview.svg
@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.40.1 (20161225.0304)
+ -->
+<!-- Title: G Pages: 1 -->
+<svg width="276pt" height="260pt"
+ viewBox="0.00 0.00 276.29 260.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 256)">
+<title>G</title>
+<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-256 272.2941,-256 272.2941,4 -4,4"/>
+<!-- Operand -->
+<g id="node1" class="node">
+<title>Operand</title>
+<ellipse fill="none" stroke="#000000" cx="62.7468" cy="-162" rx="40.8928" ry="18"/>
+<text text-anchor="middle" x="62.7468" y="-158.3" font-family="Times,serif" font-size="14.00" fill="#000000">Operand</text>
+</g>
+<!-- Constant -->
+<g id="node2" class="node">
+<title>Constant</title>
+<ellipse fill="none" stroke="#000000" cx="52.7468" cy="-90" rx="42.4939" ry="18"/>
+<text text-anchor="middle" x="52.7468" y="-86.3" font-family="Times,serif" font-size="14.00" fill="#000000">Constant</text>
+</g>
+<!-- Operand&#45;&gt;Constant -->
+<g id="edge1" class="edge">
+<title>Operand&#45;&gt;Constant</title>
+<path fill="none" stroke="#000000" d="M60.2234,-143.8314C59.1539,-136.131 57.8822,-126.9743 56.6936,-118.4166"/>
+<polygon fill="#000000" stroke="#000000" points="60.1467,-117.8367 55.3042,-108.4133 53.2133,-118.7997 60.1467,-117.8367"/>
+</g>
+<!-- Place -->
+<g id="node3" class="node">
+<title>Place</title>
+<ellipse fill="none" stroke="#000000" cx="142.7468" cy="-90" rx="29.795" ry="18"/>
+<text text-anchor="middle" x="142.7468" y="-86.3" font-family="Times,serif" font-size="14.00" fill="#000000">Place</text>
+</g>
+<!-- Operand&#45;&gt;Place -->
+<g id="edge2" class="edge">
+<title>Operand&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M80.9001,-145.6621C92.0182,-135.6558 106.3846,-122.726 118.4722,-111.8471"/>
+<polygon fill="#000000" stroke="#000000" points="120.9379,-114.3368 126.0295,-105.0456 116.2551,-109.1338 120.9379,-114.3368"/>
+</g>
+<!-- Projection -->
+<g id="node4" class="node">
+<title>Projection</title>
+<ellipse fill="none" stroke="#000000" cx="142.7468" cy="-18" rx="46.5926" ry="18"/>
+<text text-anchor="middle" x="142.7468" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">Projection</text>
+</g>
+<!-- Place&#45;&gt;Projection -->
+<g id="edge3" class="edge">
+<title>Place&#45;&gt;Projection</title>
+<path fill="none" stroke="#000000" d="M136.8311,-72.2022C136.0473,-64.3864 135.8158,-55.0171 136.1366,-46.2836"/>
+<polygon fill="#000000" stroke="#000000" points="139.6429,-46.2999 136.8018,-36.0931 132.6577,-45.8439 139.6429,-46.2999"/>
+</g>
+<!-- Local -->
+<g id="node5" class="node">
+<title>Local</title>
+<ellipse fill="none" stroke="#000000" cx="237.7468" cy="-18" rx="30.5947" ry="18"/>
+<text text-anchor="middle" x="237.7468" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">Local</text>
+</g>
+<!-- Place&#45;&gt;Local -->
+<g id="edge5" class="edge">
+<title>Place&#45;&gt;Local</title>
+<path fill="none" stroke="#000000" d="M161.5158,-75.7751C175.477,-65.194 194.7426,-50.5927 210.4126,-38.7165"/>
+<polygon fill="#000000" stroke="#000000" points="212.8361,-41.2714 218.6917,-32.4418 208.6079,-35.6926 212.8361,-41.2714"/>
+</g>
+<!-- Projection&#45;&gt;Place -->
+<g id="edge4" class="edge">
+<title>Projection&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M148.6918,-36.0931C149.4618,-43.9477 149.6794,-53.3282 149.3447,-62.0453"/>
+<polygon fill="#000000" stroke="#000000" points="145.8406,-61.9901 148.6626,-72.2022 152.8249,-62.4593 145.8406,-61.9901"/>
+</g>
+<!-- Rvalue -->
+<g id="node6" class="node">
+<title>Rvalue</title>
+<ellipse fill="none" stroke="#000000" cx="35.7468" cy="-234" rx="35.9954" ry="18"/>
+<text text-anchor="middle" x="35.7468" y="-230.3" font-family="Times,serif" font-size="14.00" fill="#000000">Rvalue</text>
+</g>
+<!-- Rvalue&#45;&gt;Operand -->
+<g id="edge6" class="edge">
+<title>Rvalue&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M42.421,-216.2022C45.4715,-208.0675 49.153,-198.2501 52.54,-189.2181"/>
+<polygon fill="#000000" stroke="#000000" points="55.8217,-190.4348 56.0559,-179.8425 49.2674,-187.9769 55.8217,-190.4348"/>
+</g>
+<!-- Assignment -->
+<g id="node7" class="node">
+<title>Assignment</title>
+<ellipse fill="none" stroke="#000000" cx="142.7468" cy="-234" rx="53.0913" ry="18"/>
+<text text-anchor="middle" x="142.7468" y="-230.3" font-family="Times,serif" font-size="14.00" fill="#000000">Assignment</text>
+</g>
+<!-- Assignment&#45;&gt;Operand -->
+<g id="edge8" class="edge">
+<title>Assignment&#45;&gt;Operand</title>
+<path fill="none" stroke="#000000" d="M123.7879,-216.937C113.2012,-207.4089 99.8654,-195.4067 88.3611,-185.0529"/>
+<polygon fill="#000000" stroke="#000000" points="90.5199,-182.287 80.7456,-178.1989 85.8371,-187.4901 90.5199,-182.287"/>
+</g>
+<!-- Assignment&#45;&gt;Place -->
+<g id="edge7" class="edge">
+<title>Assignment&#45;&gt;Place</title>
+<path fill="none" stroke="#000000" d="M142.7468,-215.7623C142.7468,-191.201 142.7468,-147.2474 142.7468,-118.3541"/>
+<polygon fill="#000000" stroke="#000000" points="146.2469,-118.0896 142.7468,-108.0896 139.2469,-118.0897 146.2469,-118.0896"/>
+</g>
+</g>
+</svg>
diff --git a/src/doc/rustc-dev-guide/src/mir/optimizations.md b/src/doc/rustc-dev-guide/src/mir/optimizations.md
new file mode 100644
index 000000000..cef785ea9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/optimizations.md
@@ -0,0 +1,136 @@
+# MIR optimizations
+
+MIR optimizations are optimizations run on the [MIR][mir] to produce better MIR
+before codegen. This is important for two reasons: first, it makes the final
+generated executable code better, and second, it means that LLVM has less work
+to do, so compilation is faster. Note that since MIR is generic (not
+[monomorphized][monomorph] yet), these optimizations are particularly
+effective; we can optimize the generic version, so all of the monomorphizations
+are cheaper!
+
+[mir]: ../mir/index.md
+[monomorph]: ../appendix/glossary.md#mono
+
+MIR optimizations run after borrow checking. We run a series of optimization
+passes over the MIR to improve it. Some passes are required to run on all code,
+some passes don't actually do optimizations but only check stuff, and some
+passes are only turned on in `release` mode.
+
+The [`optimized_mir`][optmir] [query] is called to produce the optimized MIR
+for a given [`DefId`][defid]. This query makes sure that the borrow checker has
+run and that some validation has occurred. Then, it [steals][steal] the MIR,
+optimizes it, and returns the improved MIR.
+
+[optmir]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/fn.optimized_mir.html
+[query]: ../query.md
+[defid]: ../appendix/glossary.md#def-id
+[steal]: ../mir/passes.md#stealing
+
+## Quickstart for adding a new optimization
+
+1. Make a Rust source file in `src/test/mir-opt` that shows the code you want to
+   optimize. This should be kept simple, so avoid `println!` or other formatting
+   code if it's not necessary for the optimization. The reason for this is that
+   `println!`, `format!`, etc. generate a lot of MIR that can make it harder to
+   understand what the optimization does to the test.
+
+2. Run `./x.py test --bless src/test/mir-opt/<your-test>.rs` to generate a MIR
+   dump. Read [this README][mir-opt-test-readme] for instructions on how to dump
+   things.
+
+3. Commit the current working directory state. The reason you should commit the
+   test output before you implement the optimization is so that you (and your
+   reviewers) can see a before/after diff of what the optimization changed.
+
+4. Implement a new optimization in [`compiler/rustc_mir_transform/src`].
+   The fastest and easiest way to do this is to
+
+   1. pick a small optimization (such as [`no_landing_pads`]) and copy it
+      to a new file,
+   2. add your optimization to one of the lists in the
+      [`run_optimization_passes()`] function,
+   3. and then start modifying the copied optimization.
+
+5. Rerun `./x.py test --bless src/test/mir-opt/<your-test>.rs` to regenerate the
+   MIR dumps. Look at the diffs to see if they are what you expect.
+
+6. Run `./x.py test src/test/ui` to see if your optimization broke anything.
+
+7. If there are issues with your optimization, experiment with it a bit and
+   repeat steps 5 and 6.
+
+8. Commit and open a PR. You can do this at any point, even if things aren't
+   working yet, so that you can ask for feedback on the PR. Open a "WIP" PR
+   (just prefix your PR title with `[WIP]` or otherwise note that it is a
+   work in progress) in that case.
+
+   Make sure to commit the blessed test output as well! It's necessary for CI to
+   pass and it's very helpful to reviewers.
+
+If you have any questions along the way, feel free to ask in
+`#t-compiler/wg-mir-opt` on Zulip.
+
+[mir-opt-test-readme]: https://github.com/rust-lang/rust/blob/master/src/test/mir-opt/README.md
+[`compiler/rustc_mir_transform/src`]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_mir_transform/src
+<!--- TODO: Change NoLandingPads. [#1232](https://github.com/rust-lang/rustc-dev-guide/issues/1232) -->
+[`no_landing_pads`]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_mir_transform/src/no_landing_pads.rs
+[`run_optimization_passes()`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/fn.run_optimization_passes.html
+
+## Defining optimization passes
+
+The list of passes run and the order in which they are run is defined by the
+[`run_optimization_passes`][rop] function. It contains an array of passes to
+run.  Each pass in the array is a struct that implements the [`MirPass`] trait.
+The array is an array of `&dyn MirPass` trait objects. Typically, a pass is
+implemented in its own module of the [`rustc_mir_transform`][trans] crate.
+
+[rop]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/fn.run_optimization_passes.html
+[`MirPass`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/trait.MirPass.html
+[trans]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/index.html
+
+Some examples of passes are:
+- `CleanupNonCodegenStatements`: remove some of the info that is only needed for
+  analyses, rather than codegen.
+- `ConstProp`: Does [constant propagation][constprop]
+
+You can see the ["Implementors" section of the `MirPass` rustdocs][impl] for more examples.
+
+[impl]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/trait.MirPass.html#implementors
+[constprop]: https://en.wikipedia.org/wiki/Constant_folding#Constant_propagation
+
+## MIR optimization levels
+
+MIR optimizations can come in various levels of readiness. Experimental
+optimizations may cause miscompilations, or slow down compile times.
+These passes are still included in nightly builds to gather feedback and make it easier to modify
+the pass. To enable working with slow or otherwise experimental optimization passes,
+you can specify the `-Z mir-opt-level` debug flag. You can find the
+definitions of the levels in the [compiler MCP]. If you are developing a MIR pass and
+want to query whether your optimization pass should run, you can check the
+current level using [`tcx.sess.opts.unstable_opts.mir_opt_level`][mir_opt_level].
+
+[compiler MCP]: https://github.com/rust-lang/compiler-team/issues/319
+[mir_opt_level]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/config/struct.UnstableOptions.html#structfield.mir_opt_level
+
+## Optimization fuel
+
+Optimization fuel is a compiler option (`-Z fuel=<crate>=<value>`) that allows for fine grained
+control over which optimizations can be applied during compilation: each optimization reduces
+fuel by 1, and when fuel reaches 0 no more optimizations are applied. The primary use of fuel
+is debugging optimizations that may be incorrect or misapplied. By changing the fuel
+value, you can bisect a compilation session down to the exact incorrect optimization
+(this behaves like a kind of binary search through the optimizations).
+
+MIR optimizations respect fuel, and in general each pass should check fuel by calling
+[`tcx.consider_optimizing`][consideroptimizing] and skipping the optimization if fuel
+is empty. There are a few considerations:
+
+1. If the pass is considered "guaranteed" (for example, it should always be run because it is
+needed for correctness), then fuel should not be used. An example of this is `PromoteTemps`.
+2. In some cases, an initial pass is performed to gather candidates, which are then iterated to
+perform optimizations. In these situations, we should allow for the initial gathering pass
+and then check fuel as close to the mutation as possible. This allows for the best
+debugging experience, because we can determine where in the list of candidates an optimization
+may have been misapplied. Examples of this are `InstCombine` and `ConstantPropagation`.
+
+[consideroptimizing]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.consider_optimizing
diff --git a/src/doc/rustc-dev-guide/src/mir/passes.md b/src/doc/rustc-dev-guide/src/mir/passes.md
new file mode 100644
index 000000000..5528b7762
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/passes.md
@@ -0,0 +1,102 @@
+# MIR passes
+
+If you would like to get the MIR for a function (or constant, etc),
+you can use the `optimized_mir(def_id)` query. This will give you back
+the final, optimized MIR. For foreign def-ids, we simply read the MIR
+from the other crate's metadata. But for local def-ids, the query will
+construct the MIR and then iteratively optimize it by applying a
+series of passes. This section describes how those passes work and how
+you can extend them.
+
+To produce the `optimized_mir(D)` for a given def-id `D`, the MIR
+passes through several suites of optimizations, each represented by a
+query. Each suite consists of multiple optimizations and
+transformations. These suites represent useful intermediate points
+where we want to access the MIR for type checking or other purposes:
+
+- `mir_build(D)` – not a query, but this constructs the initial MIR
+- `mir_const(D)` – applies some simple transformations to make MIR ready for
+  constant evaluation;
+- `mir_validated(D)` – applies some more transformations, making MIR ready for
+  borrow checking;
+- `optimized_mir(D)` – the final state, after all optimizations have been
+  performed.
+
+### Implementing and registering a pass
+
+A `MirPass` is some bit of code that processes the MIR, typically –
+but not always – transforming it along the way somehow. For example,
+it might perform an optimization. The `MirPass` trait itself is found
+in [the `rustc_mir_transform` crate][mirtransform], and it
+basically consists of one method, `run_pass`, that simply gets an
+`&mut Mir` (along with the tcx and some information about where it
+came from). The MIR is therefore modified in place (which helps to
+keep things efficient).
+
+A good example of a basic MIR pass is [`NoLandingPads`], which walks
+the MIR and removes all edges that are due to unwinding – this is
+used when configured with `panic=abort`, which never unwinds. As you
+can see from its source, a MIR pass is defined by first defining a
+dummy type, a struct with no fields, something like:
+
+```rust
+struct MyPass;
+```
+
+for which you then implement the `MirPass` trait. You can then insert
+this pass into the appropriate list of passes found in a query like
+`optimized_mir`, `mir_validated`, etc. (If this is an optimization, it
+should go into the `optimized_mir` list.)
+
+If you are writing a pass, there's a good chance that you are going to
+want to use a [MIR visitor]. MIR visitors are a handy way to walk all
+the parts of the MIR, either to search for something or to make small
+edits.
+
+### Stealing
+
+The intermediate queries `mir_const()` and `mir_validated()` yield up
+a `&'tcx Steal<Mir<'tcx>>`, allocated using
+`tcx.alloc_steal_mir()`. This indicates that the result may be
+**stolen** by the next suite of optimizations – this is an
+optimization to avoid cloning the MIR. Attempting to use a stolen
+result will cause a panic in the compiler. Therefore, it is important
+that you do not read directly from these intermediate queries except as
+part of the MIR processing pipeline.
+
+Because of this stealing mechanism, some care must also be taken to
+ensure that, before the MIR at a particular phase in the processing
+pipeline is stolen, anyone who may want to read from it has already
+done so. Concretely, this means that if you have some query `foo(D)`
+that wants to access the result of `mir_const(D)` or
+`mir_validated(D)`, you need to have the successor pass "force"
+`foo(D)` using `ty::queries::foo::force(...)`. This will force a query
+to execute even though you don't directly require its result.
+
+As an example, consider MIR const qualification. It wants to read the
+result produced by the `mir_const()` suite. However, that result will
+be **stolen** by the `mir_validated()` suite. If nothing was done,
+then `mir_const_qualif(D)` would succeed if it came before
+`mir_validated(D)`, but fail otherwise. Therefore, `mir_validated(D)`
+will **force** `mir_const_qualif` before it actually steals, thus
+ensuring that the reads have already happened (remember that
+[queries are memoized](../query.html), so executing a query twice
+simply loads from a cache the second time):
+
+```text
+mir_const(D) --read-by--> mir_const_qualif(D)
+     |                       ^
+  stolen-by                  |
+     |                    (forces)
+     v                       |
+mir_validated(D) ------------+
+```
+
+This mechanism is a bit dodgy. There is a discussion of more elegant
+alternatives in [rust-lang/rust#41710].
+
+[rust-lang/rust#41710]: https://github.com/rust-lang/rust/issues/41710
+[mirtransform]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/
+<!--- TODO: Change NoLandingPads. [#1232](https://github.com/rust-lang/rustc-dev-guide/issues/1232) -->
+[`NoLandingPads`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/no_landing_pads/struct.NoLandingPads.html
+[MIR visitor]: ./visitor.html
diff --git a/src/doc/rustc-dev-guide/src/mir/visitor.md b/src/doc/rustc-dev-guide/src/mir/visitor.md
new file mode 100644
index 000000000..5c21d5304
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/mir/visitor.md
@@ -0,0 +1,56 @@
+# MIR visitor
+
+The MIR visitor is a convenient tool for traversing the MIR and either
+looking for things or making changes to it. The visitor traits are
+defined in [the `rustc_middle::mir::visit` module][m-v] – there are two of
+them, generated via a single macro: `Visitor` (which operates on a
+`&Mir` and gives back shared references) and `MutVisitor` (which
+operates on a `&mut Mir` and gives back mutable references).
+
+[m-v]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/visit/index.html
+
+To implement a visitor, you have to create a type that represents
+your visitor. Typically, this type wants to "hang on" to whatever
+state you will need while processing MIR:
+
+```rust,ignore
+struct MyVisitor<...> {
+    tcx: TyCtxt<'tcx>,
+    ...
+}
+```
+
+and you then implement the `Visitor` or `MutVisitor` trait for that type:
+
+```rust,ignore
+impl<'tcx> MutVisitor<'tcx> for NoLandingPads {
+    fn visit_foo(&mut self, ...) {
+        ...
+        self.super_foo(...);
+    }
+}
+```
+
+As shown above, within the impl, you can override any of the
+`visit_foo` methods (e.g., `visit_terminator`) in order to write some
+code that will execute whenever a `foo` is found. If you want to
+recursively walk the contents of the `foo`, you then invoke the
+`super_foo` method. (NB. You never want to override `super_foo`.)
+
+A very simple example of a visitor can be found in [`NoLandingPads`].
+That visitor doesn't even require any state: it just visits all
+terminators and removes their `unwind` successors.
+
+<!--- TODO: Change NoLandingPads. [#1232](https://github.com/rust-lang/rustc-dev-guide/issues/1232) -->
+[`NoLandingPads`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/no_landing_pads/struct.NoLandingPads.html
+
+## Traversal
+
+In addition the visitor, [the `rustc_middle::mir::traversal` module][t]
+contains useful functions for walking the MIR CFG in
+[different standard orders][traversal] (e.g. pre-order, reverse
+post-order, and so forth).
+
+[t]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/traversal/index.html
+[traversal]: https://en.wikipedia.org/wiki/Tree_traversal
+
diff --git a/src/doc/rustc-dev-guide/src/miri.md b/src/doc/rustc-dev-guide/src/miri.md
new file mode 100644
index 000000000..c5de358d2
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/miri.md
@@ -0,0 +1,239 @@
+# Miri
+
+<!-- toc -->
+
+The Miri (**MIR** **I**nterpreter) engine is a virtual machine for executing MIR without
+compiling to machine code. It is usually invoked via `tcx.const_eval_*` functions.
+In the following, we will refer to the Miri engine as just "Miri", but note that
+there also is a stand-alone
+[tool called "Miri"](https://github.com/rust-lang/miri/) that is based on the
+engine (sometimes referred to as Miri-the-tool to disambiguate it from the
+engine).
+
+If you start out with a constant:
+
+```rust
+const FOO: usize = 1 << 12;
+```
+
+rustc doesn't actually invoke anything until the constant is either used or
+placed into metadata.
+
+Once you have a use-site like:
+
+```rust,ignore
+type Foo = [u8; FOO - 42];
+```
+
+The compiler needs to figure out the length of the array before being able to
+create items that use the type (locals, constants, function arguments, ...).
+
+To obtain the (in this case empty) parameter environment, one can call
+`let param_env = tcx.param_env(length_def_id);`. The `GlobalId` needed is
+
+```rust,ignore
+let gid = GlobalId {
+    promoted: None,
+    instance: Instance::mono(length_def_id),
+};
+```
+
+Invoking `tcx.const_eval(param_env.and(gid))` will now trigger the creation of
+the MIR of the array length expression. The MIR will look something like this:
+
+```mir
+Foo::{{constant}}#0: usize = {
+    let mut _0: usize;
+    let mut _1: (usize, bool);
+
+    bb0: {
+        _1 = CheckedSub(const FOO, const 42usize);
+        assert(!move (_1.1: bool), "attempt to subtract with overflow") -> bb1;
+    }
+
+    bb1: {
+        _0 = move (_1.0: usize);
+        return;
+    }
+}
+```
+
+Before the evaluation, a virtual memory location (in this case essentially a
+`vec![u8; 4]` or `vec![u8; 8]`) is created for storing the evaluation result.
+
+At the start of the evaluation, `_0` and `_1` are
+`Operand::Immediate(Immediate::Scalar(ScalarMaybeUndef::Undef))`. This is quite
+a mouthful: [`Operand`] can represent either data stored somewhere in the
+[interpreter memory](#memory) (`Operand::Indirect`), or (as an optimization)
+immediate data stored in-line.  And [`Immediate`] can either be a single
+(potentially uninitialized) [scalar value][`Scalar`] (integer or thin pointer),
+or a pair of two of them. In our case, the single scalar value is *not* (yet)
+initialized.
+
+When the initialization of `_1` is invoked, the value of the `FOO` constant is
+required, and triggers another call to `tcx.const_eval_*`, which will not be shown
+here. If the evaluation of FOO is successful, `42` will be subtracted from its
+value `4096` and the result stored in `_1` as
+`Operand::Immediate(Immediate::ScalarPair(Scalar::Raw { data: 4054, .. },
+Scalar::Raw { data: 0, .. })`. The first part of the pair is the computed value,
+the second part is a bool that's true if an overflow happened. A `Scalar::Raw`
+also stores the size (in bytes) of this scalar value; we are eliding that here.
+
+The next statement asserts that said boolean is `0`. In case the assertion
+fails, its error message is used for reporting a compile-time error.
+
+Since it does not fail, `Operand::Immediate(Immediate::Scalar(Scalar::Raw {
+data: 4054, .. }))` is stored in the virtual memory was allocated before the
+evaluation. `_0` always refers to that location directly.
+
+After the evaluation is done, the return value is converted from [`Operand`] to
+[`ConstValue`] by [`op_to_const`]: the former representation is geared towards
+what is needed *during* const evaluation, while [`ConstValue`] is shaped by the
+needs of the remaining parts of the compiler that consume the results of const
+evaluation.  As part of this conversion, for types with scalar values, even if
+the resulting [`Operand`] is `Indirect`, it will return an immediate
+`ConstValue::Scalar(computed_value)` (instead of the usual `ConstValue::ByRef`).
+This makes using the result much more efficient and also more convenient, as no
+further queries need to be executed in order to get at something as simple as a
+`usize`.
+
+Future evaluations of the same constants will not actually invoke
+Miri, but just use the cached result.
+
+[`Operand`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/enum.Operand.html
+[`Immediate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/enum.Immediate.html
+[`ConstValue`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/enum.ConstValue.html
+[`Scalar`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/enum.Scalar.html
+[`op_to_const`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/const_eval/eval_queries/fn.op_to_const.html
+
+## Datastructures
+
+Miri's outside-facing datastructures can be found in
+[rustc_middle/src/mir/interpret](https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/mir/interpret).
+This is mainly the error enum and the [`ConstValue`] and [`Scalar`] types. A
+`ConstValue` can be either `Scalar` (a single `Scalar`, i.e., integer or thin
+pointer), `Slice` (to represent byte slices and strings, as needed for pattern
+matching) or `ByRef`, which is used for anything else and refers to a virtual
+allocation. These allocations can be accessed via the methods on
+`tcx.interpret_interner`.  A `Scalar` is either some `Raw` integer or a pointer;
+see [the next section](#memory) for more on that.
+
+If you are expecting a numeric result, you can use `eval_usize` (panics on
+anything that can't be represented as a `u64`) or `try_eval_usize` which results
+in an `Option<u64>` yielding the `Scalar` if possible.
+
+## Memory
+
+To support any kind of pointers, Miri needs to have a "virtual memory" that the
+pointers can point to.  This is implemented in the [`Memory`] type.  In the
+simplest model, every global variable, stack variable and every dynamic
+allocation corresponds to an [`Allocation`] in that memory.  (Actually using an
+allocation for every MIR stack variable would be very inefficient; that's why we
+have `Operand::Immediate` for stack variables that are both small and never have
+their address taken.  But that is purely an optimization.)
+
+Such an `Allocation` is basically just a sequence of `u8` storing the value of
+each byte in this allocation.  (Plus some extra data, see below.)  Every
+`Allocation` has a globally unique `AllocId` assigned in `Memory`.  With that, a
+[`Pointer`] consists of a pair of an `AllocId` (indicating the allocation) and
+an offset into the allocation (indicating which byte of the allocation the
+pointer points to).  It may seem odd that a `Pointer` is not just an integer
+address, but remember that during const evaluation, we cannot know at which
+actual integer address the allocation will end up -- so we use `AllocId` as
+symbolic base addresses, which means we need a separate offset.  (As an aside,
+it turns out that pointers at run-time are
+[more than just integers, too](https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#pointer-provenance).)
+
+These allocations exist so that references and raw pointers have something to
+point to. There is no global linear heap in which things are allocated, but each
+allocation (be it for a local variable, a static or a (future) heap allocation)
+gets its own little memory with exactly the required size. So if you have a
+pointer to an allocation for a local variable `a`, there is no possible (no
+matter how unsafe) operation that you can do that would ever change said pointer
+to a pointer to a different local variable `b`.
+Pointer arithmetic on `a` will only ever change its offset; the `AllocId` stays the same.
+
+This, however, causes a problem when we want to store a `Pointer` into an
+`Allocation`: we cannot turn it into a sequence of `u8` of the right length!
+`AllocId` and offset together are twice as big as a pointer "seems" to be.  This
+is what the `relocation` field of `Allocation` is for: the byte offset of the
+`Pointer` gets stored as a bunch of `u8`, while its `AllocId` gets stored
+out-of-band.  The two are reassembled when the `Pointer` is read from memory.
+The other bit of extra data an `Allocation` needs is `undef_mask` for keeping
+track of which of its bytes are initialized.
+
+### Global memory and exotic allocations
+
+`Memory` exists only during the Miri evaluation; it gets destroyed when the
+final value of the constant is computed.  In case that constant contains any
+pointers, those get "interned" and moved to a global "const eval memory" that is
+part of `TyCtxt`.  These allocations stay around for the remaining computation
+and get serialized into the final output (so that dependent crates can use
+them).
+
+Moreover, to also support function pointers, the global memory in `TyCtxt` can
+also contain "virtual allocations": instead of an `Allocation`, these contain an
+`Instance`.  That allows a `Pointer` to point to either normal data or a
+function, which is needed to be able to evaluate casts from function pointers to
+raw pointers.
+
+Finally, the [`GlobalAlloc`] type used in the global memory also contains a
+variant `Static` that points to a particular `const` or `static` item.  This is
+needed to support circular statics, where we need to have a `Pointer` to a
+`static` for which we cannot yet have an `Allocation` as we do not know the
+bytes of its value.
+
+[`Memory`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/interpret/struct.Memory.html
+[`Allocation`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/struct.Allocation.html
+[`Pointer`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/struct.Pointer.html
+[`GlobalAlloc`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/interpret/enum.GlobalAlloc.html
+
+### Pointer values vs Pointer types
+
+One common cause of confusion in Miri is that being a pointer *value* and having
+a pointer *type* are entirely independent properties.  By "pointer value", we
+refer to a `Scalar::Ptr` containing a `Pointer` and thus pointing somewhere into
+Miri's virtual memory.  This is in contrast to `Scalar::Raw`, which is just some
+concrete integer.
+
+However, a variable of pointer or reference *type*, such as `*const T` or `&T`,
+does not have to have a pointer *value*: it could be obtained by casting or
+transmuting an integer to a pointer. 
+And similarly, when casting or transmuting a reference to some
+actual allocation to an integer, we end up with a pointer *value*
+(`Scalar::Ptr`) at integer *type* (`usize`).  This is a problem because we
+cannot meaningfully perform integer operations such as division on pointer
+values.
+
+## Interpretation
+
+Although the main entry point to constant evaluation is the `tcx.const_eval_*`
+functions, there are additional functions in
+[rustc_const_eval/src/const_eval](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_const_eval/index.html)
+that allow accessing the fields of a `ConstValue` (`ByRef` or otherwise). You should
+never have to access an `Allocation` directly except for translating it to the
+compilation target (at the moment just LLVM).
+
+Miri starts by creating a virtual stack frame for the current constant that is
+being evaluated. There's essentially no difference between a constant and a
+function with no arguments, except that constants do not allow local (named)
+variables at the time of writing this guide.
+
+A stack frame is defined by the `Frame` type in
+[rustc_const_eval/src/interpret/eval_context.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/eval_context.rs)
+and contains all the local
+variables memory (`None` at the start of evaluation). Each frame refers to the
+evaluation of either the root constant or subsequent calls to `const fn`. The
+evaluation of another constant simply calls `tcx.const_eval_*`, which produce an
+entirely new and independent stack frame.
+
+The frames are just a `Vec<Frame>`, there's no way to actually refer to a
+`Frame`'s memory even if horrible shenanigans are done via unsafe code. The only
+memory that can be referred to are `Allocation`s.
+
+Miri now calls the `step` method (in
+[rustc_const_eval/src/interpret/step.rs](https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/step.rs)
+) until it either returns an error or has no further statements to execute. Each
+statement will now initialize or modify the locals or the virtual memory
+referred to by a local. This might require evaluating other constants or
+statics, which just recursively invokes `tcx.const_eval_*`.
diff --git a/src/doc/rustc-dev-guide/src/name-resolution.md b/src/doc/rustc-dev-guide/src/name-resolution.md
new file mode 100644
index 000000000..c4f44909b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/name-resolution.md
@@ -0,0 +1,181 @@
+# Name resolution
+
+<!-- toc -->
+
+In the previous chapters, we saw how the AST is built with all macros expanded.
+We saw how doing that requires doing some name resolution to resolve imports
+and macro names. In this chapter, we show how this is actually done and more.
+
+In fact, we don't do full name resolution during macro expansion -- we only
+resolve imports and macros at that time. This is required to know what to even
+expand. Later, after we have the whole AST, we do full name resolution to
+resolve all names in the crate. This happens in [`rustc_resolve::late`][late].
+Unlike during macro expansion, in this late expansion, we only need to try to
+resolve a name once, since no new names can be added. If we fail to resolve a
+name now, then it is a compiler error.
+
+Name resolution can be complex. There are a few different namespaces (e.g.
+macros, values, types, lifetimes), and names may be valid at different (nested)
+scopes. Also, different types of names can fail to be resolved differently, and
+failures can happen differently at different scopes. For example, for a module
+scope, failure means no unexpanded macros and no unresolved glob imports in
+that module. On the other hand, in a function body, failure requires that a
+name be absent from the block we are in, all outer scopes, and the global
+scope.
+
+[late]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/late/index.html
+
+## Basics
+
+In our programs we can refer to variables, types, functions, etc, by giving them
+a name. These names are not always unique. For example, take this valid Rust
+program:
+
+```rust
+type x = u32;
+let x: x = 1;
+let y: x = 2;
+```
+
+How do we know on line 3 whether `x` is a type (u32) or a value (1)? These
+conflicts are resolved during name resolution. In this specific case, name
+resolution defines that type names and variable names live in separate
+namespaces and therefore can co-exist.
+
+The name resolution in Rust is a two-phase process. In the first phase, which runs
+during macro expansion, we build a tree of modules and resolve imports. Macro
+expansion and name resolution communicate with each other via the
+[`ResolverAstLoweringExt`] trait.
+
+The input to the second phase is the syntax tree, produced by parsing input
+files and expanding macros. This phase produces links from all the names in the
+source to relevant places where the name was introduced. It also generates
+helpful error messages, like typo suggestions, traits to import or lints about
+unused items.
+
+A successful run of the second phase ([`Resolver::resolve_crate`]) creates kind
+of an index the rest of the compilation may use to ask about the present names
+(through the `hir::lowering::Resolver` interface).
+
+The name resolution lives in the `rustc_resolve` crate, with the meat in
+`lib.rs` and some helpers or symbol-type specific logic in the other modules.
+
+[`Resolver::resolve_crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/struct.Resolver.html#method.resolve_crate
+[`ResolverAstLoweringExt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_lowering/trait.ResolverAstLoweringExt.html
+
+## Namespaces
+
+Different kind of symbols live in different namespaces ‒ e.g. types don't
+clash with variables. This usually doesn't happen, because variables start with
+lower-case letter while types with upper case one, but this is only a
+convention. This is legal Rust code that'll compile (with warnings):
+
+```rust
+type x = u32;
+let x: x = 1;
+let y: x = 2; // See? x is still a type here.
+```
+
+To cope with this, and with slightly different scoping rules for these
+namespaces, the resolver keeps them separated and builds separate structures for
+them.
+
+In other words, when the code talks about namespaces, it doesn't mean the module
+hierarchy, it's types vs. values vs. macros.
+
+## Scopes and ribs
+
+A name is visible only in certain area in the source code. This forms a
+hierarchical structure, but not necessarily a simple one ‒ if one scope is
+part of another, it doesn't mean the name visible in the outer one is also
+visible in the inner one, or that it refers to the same thing.
+
+To cope with that, the compiler introduces the concept of Ribs. This is
+abstraction of a scope. Every time the set of visible names potentially changes,
+a new rib is pushed onto a stack. The places where this can happen includes for
+example:
+
+* The obvious places ‒ curly braces enclosing a block, function boundaries,
+  modules.
+* Introducing a let binding ‒ this can shadow another binding with the same
+  name.
+* Macro expansion border ‒ to cope with macro hygiene.
+
+When searching for a name, the stack of ribs is traversed from the innermost
+outwards. This helps to find the closest meaning of the name (the one not
+shadowed by anything else). The transition to outer rib may also change the
+rules what names are usable ‒ if there are nested functions (not closures),
+the inner one can't access parameters and local bindings of the outer one,
+even though they should be visible by ordinary scoping rules. An example:
+
+```rust
+fn do_something<T: Default>(val: T) { // <- New rib in both types and values (1)
+    // `val` is accessible, as is the helper function
+    // `T` is accessible
+    let helper = || { // New rib on `helper` (2) and another on the block (3)
+        // `val` is accessible here
+    }; // End of (3)
+    // `val` is accessible, `helper` variable shadows `helper` function
+    fn helper() { // <- New rib in both types and values (4)
+        // `val` is not accessible here, (4) is not transparent for locals)
+        // `T` is not accessible here
+    } // End of (4)
+    let val = T::default(); // New rib (5)
+    // `val` is the variable, not the parameter here
+} // End of (5), (2) and (1)
+```
+
+Because the rules for different namespaces are a bit different, each namespace
+has its own independent rib stack that is constructed in parallel to the others.
+In addition, there's also a rib stack for local labels (e.g. names of loops or
+blocks), which isn't a full namespace in its own right.
+
+## Overall strategy
+
+To perform the name resolution of the whole crate, the syntax tree is traversed
+top-down and every encountered name is resolved. This works for most kinds of
+names, because at the point of use of a name it is already introduced in the Rib
+hierarchy.
+
+There are some exceptions to this. Items are bit tricky, because they can be
+used even before encountered ‒ therefore every block needs to be first scanned
+for items to fill in its Rib.
+
+Other, even more problematic ones, are imports which need recursive fixed-point
+resolution and macros, that need to be resolved and expanded before the rest of
+the code can be processed.
+
+Therefore, the resolution is performed in multiple stages.
+
+## Speculative crate loading
+
+To give useful errors, rustc suggests importing paths into scope if they're
+not found. How does it do this? It looks through every module of every crate
+and looks for possible matches. This even includes crates that haven't yet
+been loaded!
+
+Loading crates for import suggestions that haven't yet been loaded is called
+_speculative crate loading_, because any errors it encounters shouldn't be
+reported: resolve decided to load them, not the user. The function that does
+this is `lookup_import_candidates` and lives in
+`rustc_resolve/src/diagnostics.rs`.
+
+To tell the difference between speculative loads and loads initiated by the
+user, resolve passes around a `record_used` parameter, which is `false` when
+the load is speculative.
+
+## TODO: [#16](https://github.com/rust-lang/rustc-dev-guide/issues/16)
+
+This is a result of the first pass of learning the code. It is definitely
+incomplete and not detailed enough. It also might be inaccurate in places.
+Still, it probably provides useful first guidepost to what happens in there.
+
+* What exactly does it link to and how is that published and consumed by
+  following stages of compilation?
+* Who calls it and how it is actually used.
+* Is it a pass and then the result is only used, or can it be computed
+  incrementally (e.g. for RLS)?
+* The overall strategy description is a bit vague.
+* Where does the name `Rib` come from?
+* Does this thing have its own tests, or is it tested only as part of some e2e
+  testing?
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/about.md b/src/doc/rustc-dev-guide/src/notification-groups/about.md
new file mode 100644
index 000000000..260c59c24
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/about.md
@@ -0,0 +1,99 @@
+# Notification groups
+
+The **notification groups** are an easy way to help out with rustc in a
+"piece-meal" fashion, without committing to a larger project.
+Notification groups are **[easy to join](#join)** (just submit a PR!)
+and joining does not entail any particular commitment.
+
+Once you [join a notification group](#join), you will be added to
+a list that receives pings on github whenever a new issue is found
+that fits the notification group's criteria. If you are interested, you
+can then [claim the issue] and start working on it.
+
+Of course, you don't have to wait for new issues to be tagged! If you
+prefer, you can use the Github label for a notification group to
+search for existing issues that haven't been claimed yet.
+
+[claim the issue]: https://github.com/rust-lang/triagebot/wiki/Assignment
+
+## List of notification groups
+
+Here's the list of the notification groups:
+- [ARM](./arm.md)
+- [Cleanup Crew](./cleanup-crew.md)
+- [LLVM](./llvm.md)
+- [RISC-V](./risc-v.md)
+- [Windows](./windows.md)
+
+## What issues are a good fit for notification groups?
+
+Notification groups tend to get pinged on **isolated** bugs,
+particularly those of **middle priority**:
+
+- By **isolated**, we mean that we do not expect large-scale refactoring
+  to be required to fix the bug.
+- By **middle priority**, we mean that we'd like to see the bug fixed,
+  but it's not such a burning problem that we are dropping everything
+  else to fix it. The danger with such bugs, of course, is that they
+  can accumulate over time, and the role of the notification group is
+  to try and stop that from happening!
+
+<a name="join"></a>
+
+## Joining a notification group
+
+To join an notification group, you just have to open a PR adding your
+Github username to the appropriate file in the Rust team repository.
+See the "example PRs" below to get a precise idea and to identify the
+file to edit.
+
+Also, if you are not already a member of a Rust team then -- in addition
+to adding your name to the file -- you have to checkout the repository and
+run the following command:
+
+```bash
+cargo run add-person $your_user_name
+```
+
+Example PRs:
+
+* [Example of adding yourself to the ARM group.](https://github.com/rust-lang/team/pull/358)
+* [Example of adding yourself to the Cleanup Crew.](https://github.com/rust-lang/team/pull/221)
+* [Example of adding yourself to the LLVM group.](https://github.com/rust-lang/team/pull/140)
+* [Example of adding yourself to the RISC-V group.](https://github.com/rust-lang/team/pull/394)
+* [Example of adding yourself to the Windows group.](https://github.com/rust-lang/team/pull/348)
+
+## Tagging an issue for a notification group
+
+To tag an issue as appropriate for a notification group, you give
+[rustbot] a [`ping`] command with the name of the notification
+group. For example:
+
+```text
+@rustbot ping llvm
+@rustbot ping cleanup-crew
+@rustbot ping windows
+@rustbot ping arm
+```
+
+To make some commands shorter and easier to remember, there are aliases,
+defined in the [`triagebot.toml`] file. For example, all of these commands
+are equivalent and will ping the Cleanup Crew:
+
+```text
+@rustbot ping cleanup
+@rustbot ping bisect
+@rustbot ping reduce
+```
+
+Keep in mind that these aliases are meant to make humans' life easier.
+They might be subject to change. If you need to ensure that a command
+will always be valid, prefer the full invocations over the aliases.
+
+**Note though that this should only be done by compiler team members
+or contributors, and is typically done as part of compiler team
+triage.**
+
+[rustbot]: https://github.com/rust-lang/triagebot/
+[`ping`]: https://github.com/rust-lang/triagebot/wiki/Pinging
+[`triagebot.toml`]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/arm.md b/src/doc/rustc-dev-guide/src/notification-groups/arm.md
new file mode 100644
index 000000000..4514f8ef3
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/arm.md
@@ -0,0 +1,22 @@
+# ARM notification group
+
+**Github Label:** [O-ARM]
+
+[O-ARM]: https://github.com/rust-lang/rust/labels/O-ARM
+
+This list will be used to ask for help both in diagnosing and testing
+ARM-related issues as well as suggestions on how to resolve
+interesting questions regarding our ARM support.
+
+The group also has an associated Zulip stream ([`#t-compiler/arm`])
+where people can go to pose questions and discuss ARM-specific
+topics.
+
+So, if you are interested in participating, please sign up for the
+ARM group! To do so, open a PR against the [rust-lang/team]
+repository. Just [follow this example][eg], but change the username to
+your own!
+
+[`#t-compiler/arm`]: https://rust-lang.zulipchat.com/#narrow/stream/242906-t-compiler.2Farm
+[rust-lang/team]: https://github.com/rust-lang/team
+[eg]: https://github.com/rust-lang/team/pull/358
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/cleanup-crew.md b/src/doc/rustc-dev-guide/src/notification-groups/cleanup-crew.md
new file mode 100644
index 000000000..436b51fd1
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/cleanup-crew.md
@@ -0,0 +1,114 @@
+# Cleanup Crew
+
+**Github Label:** [ICEBreaker-Cleanup-Crew]
+
+[ICEBreaker-Cleanup-Crew]: https://github.com/rust-lang/rust/labels/ICEBreaker-Cleanup-Crew
+
+The "Cleanup Crew" are focused on improving bug reports. Specifically,
+the goal is to try to ensure that every bug report has all the
+information that will be needed for someone to fix it:
+
+* a minimal, standalone example that shows the problem
+* links to duplicates or related bugs
+* if the bug is a regression (something that used to work, but no longer does),
+  then a bisection to the PR or nightly that caused the regression
+
+This kind of cleanup is invaluable in getting bugs fixed. Better
+still, it can be done by anybody who knows Rust, without any
+particularly deep knowledge of the compiler.
+
+Let's look a bit at the workflow for doing "cleanup crew" actions.
+
+## Finding a minimal, standalone example
+
+Here the ultimate goal is to produce an example that reproduces the same
+problem but without relying on any external crates. Such a test ought to contain
+as little code as possible, as well. This will make it much easier to isolate the problem.
+
+However, even if the "ultimate minimal test" cannot be achieved, it's
+still useful to post incremental minimizations. For example, if you
+can eliminate some of the external dependencies, that is helpful, and
+so forth. 
+
+It's particularly useful to reduce to an example that works
+in the [Rust playground](https://play.rust-lang.org/), rather than
+requiring people to checkout a cargo build.
+
+There are many resources for how to produce minimized test cases. Here
+are a few:
+
+* The [rust-reduce](https://github.com/jethrogb/rust-reduce) tool can try to reduce
+  code automatically.
+  * The [C-reduce](https://embed.cs.utah.edu/creduce/) tool also works
+    on Rust code, though it requires that you start from a single
+    file. (XXX link to some post explaining how to do it?)
+* pnkfelix's [Rust Bug Minimization Patterns] blog post
+  * This post focuses on "heavy bore" techniques, where you are
+    starting with a large, complex cargo project that you wish to
+    narrow down to something standalone.
+
+[Rust Bug Minimization Patterns]: http://blog.pnkfx.org/blog/2019/11/18/rust-bug-minimization-patterns/
+
+## Links to duplicate or related bugs
+
+If you are on the "Cleanup Crew", you will sometimes see multiple bug
+reports that seem very similar. You can link one to the other just by
+mentioning the other bug number in a Github comment. Sometimes it is
+useful to close duplicate bugs. But if you do so, you should always
+copy any test case from the bug you are closing to the other bug that
+remains open, as sometimes duplicate-looking bugs will expose
+different facets of the same problem.
+
+## Bisecting regressions
+
+For regressions (something that used to work, but no longer does), it
+is super useful if we can figure out precisely when the code stopped
+working.  The gold standard is to be able to identify the precise
+**PR** that broke the code, so we can ping the author, but even
+narrowing it down to a nightly build is helpful, especially as that
+then gives us a range of PRs. (One other challenge is that we
+sometimes land "rollup" PRs, which combine multiple PRs into one.)
+
+### cargo-bisect-rustc
+
+To help in figuring out the cause of a regression we have a tool
+called [cargo-bisect-rustc]. It will automatically download and test
+various builds of rustc. For recent regressions, it is even able to
+use the builds from our CI to track down the regression to a specific
+PR; for older regressions, it will simply identify a nightly.
+
+To learn to use [cargo-bisect-rustc], check out [this blog
+post][learn], which gives a quick introduction to how it works. You
+can also ask questions at the Zulip stream
+[`#t-compiler/cargo-bisect-rustc`][zcbr], or help in improving the tool.
+
+[cargo-bisect-rustc]: https://github.com/rust-lang/cargo-bisect-rustc/
+[learn]: https://blog.rust-lang.org/inside-rust/2019/12/18/bisecting-rust-compiler.html
+[zcbr]: https://rust-lang.zulipchat.com/#narrow/stream/217417-t-compiler.2Fcargo-bisect-rustc
+
+### identifying the range of PRs in a nightly
+
+If the regression occurred more than 90 days ago, then
+cargo-bisect-rustc will not able to identify the particular PR that
+caused the regression, just the nightly build. In that case, we can
+identify the set of PRs that this corresponds to by using the git
+history. 
+
+The command `rustc +nightly -vV` will cause rustc to output a number
+of useful bits of version info, including the `commit-hash`. Given the
+commit-hash of two nightly versions, you can find all of PRs that have
+landed in between by taking the following steps:
+
+1. Go to an update checkout of the [rust-lang/rust] repository
+2. Execute the command `git log --author=bors --format=oneline SHA1..SHA2`
+  * This will list out all of the commits by bors, which is our merge bot
+  * Each commit corresponds to one PR, and information about the PR should be in the description
+3. Copy and paste that information into the bug report
+
+Often, just eye-balling the PR descriptions (which are included in the
+commit messages) will give you a good idea which one likely caused the
+problem. But if you're unsure feel free to just ping the compiler team
+(`@rust-lang/compiler`) or else to ping the authors of the PR
+themselves.
+
+[rust-lang/rust]: https://github.com/rust-lang/rust/
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/llvm.md b/src/doc/rustc-dev-guide/src/notification-groups/llvm.md
new file mode 100644
index 000000000..69edd8b54
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/llvm.md
@@ -0,0 +1,34 @@
+# LLVM Notification group
+
+**Github Label:** [A-LLVM]
+
+[A-LLVM]: https://github.com/rust-lang/rust/labels/A-LLVM
+
+The "LLVM Notification Group" are focused on bugs that center around LLVM.
+These bugs often arise because of LLVM optimizations gone awry, or as
+the result of an LLVM upgrade. The goal here is:
+
+- to determine whether the bug is a result of us generating invalid LLVM IR,
+  or LLVM misoptimizing;
+- if the former, to fix our IR;
+- if the latter, to try and file a bug on LLVM (or identify an existing bug).
+
+The group may also be asked to weigh in on other sorts of LLVM-focused
+questions.
+
+## Helpful tips and options
+
+The ["Debugging LLVM"][d] section of the
+rustc-dev-guide gives a step-by-step process for how to help debug bugs
+caused by LLVM. In particular, it discusses how to emit LLVM IR, run
+the LLVM IR optimization pipelines, and so forth. You may also find
+it useful to look at the various codegen options listed under `-C help`
+and the internal options under `-Z help` -- there are a number that
+pertain to LLVM (just search for LLVM).
+
+[d]: ../backend/debugging.md
+
+## If you do narrow to an LLVM bug
+
+The ["Debugging LLVM"][d] section also describes what to do once
+you've identified the bug.
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md b/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md
new file mode 100644
index 000000000..15ce1cfc6
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md
@@ -0,0 +1,22 @@
+# RISC-V notification group
+
+**Github Label:** [O-riscv]
+
+[O-riscv]: https://github.com/rust-lang/rust/labels/O-riscv
+
+This list will be used to ask for help both in diagnosing and testing
+RISC-V-related issues as well as suggestions on how to resolve
+interesting questions regarding our RISC-V support.
+
+The group also has an associated Zulip stream ([`#t-compiler/risc-v`])
+where people can go to pose questions and discuss RISC-V-specific
+topics.
+
+So, if you are interested in participating, please sign up for the
+RISC-V group! To do so, open a PR against the [rust-lang/team]
+repository. Just [follow this example][eg], but change the username to
+your own!
+
+[`#t-compiler/risc-v`]: https://rust-lang.zulipchat.com/#narrow/stream/250483-t-compiler.2Frisc-v
+[rust-lang/team]: https://github.com/rust-lang/team
+[eg]: https://github.com/rust-lang/team/pull/394
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/windows.md b/src/doc/rustc-dev-guide/src/notification-groups/windows.md
new file mode 100644
index 000000000..0483babd8
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/notification-groups/windows.md
@@ -0,0 +1,32 @@
+# Windows notification group
+
+**Github Label:** [O-Windows]
+
+[O-Windows]: https://github.com/rust-lang/rust/labels/O-Windows
+
+This list will be used to ask for help both in diagnosing and testing
+Windows-related issues as well as suggestions on how to resolve
+interesting questions regarding our Windows support.
+
+The group also has an associated Zulip stream ([`#t-compiler/windows`])
+where people can go to pose questions and discuss Windows-specific
+topics.
+
+To get a better idea for what the group will do, here are some
+examples of the kinds of questions where we would have reached out to
+the group for advice in determining the best course of action:
+
+* Which versions of MinGW should we support?
+* Should we remove the legacy InnoSetup GUI installer? [#72569]
+* What names should we use for static libraries on Windows? [#29520]
+
+So, if you are interested in participating, please sign up for the
+Windows group! To do so, open a PR against the [rust-lang/team]
+repository. Just [follow this example][eg], but change the username to
+your own!
+
+[`#t-compiler/windows`]: https://rust-lang.zulipchat.com/#streams/242869/t-compiler.2Fwindows
+[rust-lang/team]: https://github.com/rust-lang/team
+[eg]: https://github.com/rust-lang/team/pull/348/
+[#72569]: https://github.com/rust-lang/rust/pull/72569
+[#29520]: https://github.com/rust-lang/rust/pull/29520
diff --git a/src/doc/rustc-dev-guide/src/opaque-types-impl-trait-inference.md b/src/doc/rustc-dev-guide/src/opaque-types-impl-trait-inference.md
new file mode 100644
index 000000000..52d2127bf
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/opaque-types-impl-trait-inference.md
@@ -0,0 +1,277 @@
+# Inference of opaque types (`impl Trait`)
+
+This page describes how the compiler infers the [hidden type] for an [opaque type].
+This kind of type inference is particularly complex because,
+unlike other kinds of type inference,
+it can work across functions and function bodies.
+
+[hidden type]: https://rustc-dev-guide.rust-lang.org/borrow_check/region_inference/member_constraints.html?highlight=%22hidden%20type%22#member-constraints
+[opaque type]: https://rustc-dev-guide.rust-lang.org/opaque-types-type-alias-impl-trait.html
+
+## Running example
+
+To help explain how it works, let's consider an example.
+
+```rust
+mod m {
+    pub type Seq<T> = impl IntoIterator<Item = T>;
+
+    pub fn produce_singleton<T>(t: T) -> Seq<T> {
+        vec![t]
+    }
+
+    pub fn produce_doubleton<T>(t: T, u: T) -> Seq<T> {
+        vec![t, u]
+    }
+}
+
+fn is_send<T: Send>(_: &T) {}
+
+pub fn main() {
+    let elems = m::produce_singleton(22);
+
+    is_send(&elems);
+
+    for elem in elems {
+        println!("elem = {:?}", elem);
+    }
+}
+```
+
+In this code, the *opaque type* is `Seq<T>`.
+Its defining scope is the module `m`.
+Its *hidden type* is `Vec<T>`,
+which is inferred from `m::produce_singleton` and `m::produce_doubleton`.
+
+In the `main` function, the opaque type is out of its defining scope.
+When `main` calls `m::produce_singleton`, it gets back a reference to the opaque type `Seq<i32>`.
+The `is_send` call checks that `Seq<i32>: Send`.
+`Send` is not listed amongst the bounds of the impl trait,
+but because of auto-trait leakage, we are able to infer that it holds.
+The `for` loop desugaring requires that `Seq<T>: IntoIterator`,
+which is provable from the bounds declared on `Seq<T>`.
+
+### Type-checking `main`
+
+Let's start by looking what happens when we type-check `main`.
+Initially we invoke `produce_singleton` and the return type is an opaque type
+[`OpaqueTy`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/enum.ItemKind.html#variant.OpaqueTy).
+
+#### Type-checking the for loop
+
+The for loop desugars the `in elems` part to `IntoIterator::into_iter(elems)`.
+`elems` is of type `Seq<T>`, so the type checker registers a `Seq<T>: IntoIterator` obligation.
+This obligation is trivially satisfied,
+because `Seq<T>` is an opaque type (`impl IntoIterator<Item = T>`) that has a bound for the trait.
+Similar to how a `U: Foo` where bound allows `U` to trivially satisfy `Foo`,
+opaque types' bounds are available to the type checker and are used to fulfill obligations.
+
+The type of `elem` in the for loop is inferred to be `<Seq<T> as IntoIterator>::Item`, which is `T`.
+At no point is the type checker interested in the hidden type.
+
+#### Type-checking the `is_send` call
+
+When trying to prove auto trait bounds,
+we first repeat the process as above,
+to see if the auto trait is in the bound list of the opaque type.
+If that fails, we reveal the hidden type of the opaque type,
+but only to prove this specific trait bound, not in general.
+Revealing is done by invoking the `type_of` query on the `DefId` of the opaque type.
+The query will internally request the hidden types from the defining function(s)
+and return that (see [the section on `type_of`](#Within-the-type_of-query) for more details).
+
+#### Flowchart of type checking steps
+
+```mermaid
+flowchart TD
+    TypeChecking["type checking `main`"]
+    subgraph TypeOfSeq["type_of(Seq<T>) query"]
+        WalkModuleHir["Walk the HIR for the module `m`\nto find the hidden types from each\nfunction/const/static within"]
+        VisitProduceSingleton["visit `produce_singleton`"]
+        InterimType["`produce_singleton` hidden type is `Vec<T>`\nkeep searching"]
+        VisitProduceDoubleton["visit `produce_doubleton`"]
+        CompareType["`produce_doubleton` hidden type is also Vec<T>\nthis matches what we saw before ✅"]
+        Done["No more items to look at in scope\nReturn `Vec<T>`"]
+    end
+
+    BorrowCheckProduceSingleton["`borrow_check(produce_singleton)`"]
+    TypeCheckProduceSingleton["`type_check(produce_singleton)`"]
+
+    BorrowCheckProduceDoubleton["`borrow_check(produce_doubleton)`"]
+    TypeCheckProduceDoubleton["`type_check(produce_doubleton)`"]
+
+    Substitute["Substitute `T => u32`,\nyielding `Vec<i32>` as the hidden type"]
+    CheckSend["Check that `Vec<i32>: Send` ✅"]
+
+    TypeChecking -- trait code for auto traits --> TypeOfSeq
+    TypeOfSeq --> WalkModuleHir
+    WalkModuleHir --> VisitProduceSingleton
+    VisitProduceSingleton --> BorrowCheckProduceSingleton
+    BorrowCheckProduceSingleton --> TypeCheckProduceSingleton
+    TypeCheckProduceSingleton --> InterimType
+    InterimType --> VisitProduceDoubleton
+    VisitProduceDoubleton --> BorrowCheckProduceDoubleton
+    BorrowCheckProduceDoubleton --> TypeCheckProduceDoubleton
+    TypeCheckProduceDoubleton --> CompareType --> Done
+    Done --> Substitute --> CheckSend
+```
+
+### Within the `type_of` query
+
+The `type_of` query, when applied to an opaque type O, returns the hidden type.
+That hidden type is computed by combining the results
+from each constraining function within the defining scope of O.
+
+```mermaid
+flowchart TD
+    TypeOf["type_of query"]
+    TypeOf -- find_opaque_ty_constraints --> FindOpaqueTyConstraints
+    FindOpaqueTyConstraints --> Iterate
+    Iterate["Iterate over each item in defining scope"]
+    Iterate -- For each item --> TypeCheck
+    TypeCheck["Check typeck(I) to see if it constraints O"]
+    TypeCheck -- I does not\nconstrain O --> Iterate
+    TypeCheck -- I constrains O --> BorrowCheck
+    BorrowCheck["Invoke mir_borrowck(I) to get hidden type\nfor O computed by I"]
+    BorrowCheck --> PreviousType
+    PreviousType["Hidden type from I\nsame as any previous hidden type\nfound so far?"]
+    PreviousType -- Yes --> Complete
+    PreviousType -- No --> ReportError
+    ReportError["Report an error"]
+    ReportError --> Complete["Item I complete"]
+    Complete --> Iterate
+
+    FindOpaqueTyConstraints -- All constraints found --> Done
+    Done["Done"]
+```
+
+### Relating an opaque type to another type
+
+There is one central place where an opaqe type gets its hidden type constrained,
+and that is the `handle_opaque_type` function.
+Amusingly it takes two types, so you can pass any two types,
+but one of them should be an opaque type.
+The order is only important for diagnostics.
+
+```mermaid
+flowchart TD
+    subgraph typecheck["type check comparison routines"]
+        equate.rs
+        sub.rs
+        lub.rs
+    end
+
+    typecheck --> TwoSimul
+
+    subgraph handleopaquetype["infcx.handle_opaque_type"]
+
+        TwoSimul["Defining two opaque types simultaneously?"]
+
+        TwoSimul -- Yes --> ReportError["Report error"]
+
+        TwoSimul -- No --> MayDefine -- Yes --> RegisterOpaqueType --> AlreadyHasValue
+
+        MayDefine -- No --> ReportError
+
+        MayDefine["In defining scope OR in query?"]
+
+        AlreadyHasValue["Opaque type X already has\na registered value?"]
+
+        AlreadyHasValue -- No --> Obligations["Register opaque type bounds\nas obligations for hidden type"]
+
+        RegisterOpaqueType["Register opaque type with\nother type as value"]
+
+        AlreadyHasValue -- Yes --> EquateOpaqueTypes["Equate new hidden type\nwith old hidden type"]
+    end
+```
+
+### Interactions with queries
+
+When queries handle opaque types,
+they cannot figure out whether they are in a defining scope,
+so they just assume they are.
+
+The registered hidden types are stored into the `QueryResponse` struct
+in the `opaque_types` field (the function
+`take_opaque_types_for_query_response` reads them out).
+
+When the `QueryResponse` is instantiated into the surrounding infcx in
+`query_response_substitution_guess`,
+we convert each hidden type constraint by invoking `handle_opaque_type` (as above).
+
+There is one bit of "weirdness".
+The instantiated opaque types have an order
+(if one opaque type was compared with another,
+and we have to pick one opaque type to use as the one that gets its hidden type assigned).
+We use the one that is considered "expected".
+But really both of the opaque types may have defining uses.
+When the query result is instantiated,
+that will be re-evaluated from the context that is using the query.
+The final context (typeck of a function, mir borrowck or wf-checks)
+will know which opaque type can actually be instantiated
+and then handle it correctly.
+
+### Within the MIR borrow checker
+
+The MIR borrow checker relates things via `nll_relate` and only cares about regions.
+Any type relation will trigger the binding of hidden types,
+so the borrow checker is doing the same thing as the type checker,
+but ignores obivously dead code (e.g. after a panic).
+The borrow checker is also the source of truth when it comes to hidden types,
+as it is the only one who can properly figure out what lifetimes on the hidden type correspond
+to which lifetimes on the opaque type declaration.
+
+## Backwards compatibility hacks
+
+`impl Trait` in return position has various quirks that were not part
+of any RFCs and are likely accidental stabilizations.
+To support these,
+the `replace_opaque_types_with_inference_vars` is being used to reintroduce the previous behaviour.
+
+There are three backwards compatibility hacks:
+
+1. All return sites share the same inference variable,
+   so some return sites may only compile if another return site uses a concrete type.
+    ```rust
+    fn foo() -> impl Debug {
+        if false {
+            return std::iter::empty().collect();
+        }
+        vec![42]
+    }
+    ```
+2. Associated type equality constraints for `impl Trait` can be used
+   as long as the hidden type  satisfies the trait bounds on the associated type.
+   The opaque `impl Trait` signature does not need to satisfy them.
+
+    ```rust
+    trait Duh {}
+
+    impl Duh for i32 {}
+
+    trait Trait {
+        type Assoc: Duh;
+    }
+
+    // the fact that `R` is the `::Output` projection on `F` causes
+    // an intermediate inference var to be generated which is then later
+    // compared against the actually found `Assoc` type.
+    impl<R: Duh, F: FnMut() -> R> Trait for F {
+        type Assoc = R;
+    }
+
+    // The `impl Send` here is then later compared against the inference var
+    // created, causing the inference var to be set to `impl Send` instead of
+    // the hidden type. We already have obligations registered on the inference
+    // var to make it uphold the `: Duh` bound on `Trait::Assoc`. The opaque
+    // type does not implement `Duh`, even if its hidden type does.
+    // Lazy TAIT would error out, but we inserted a hack to make it work again,
+    // keeping backwards compatibility.
+    fn foo() -> impl Trait<Assoc = impl Send> {
+        || 42
+    }
+    ```
+3. Closures cannot create hidden types for their parent function's `impl Trait`.
+   This point is mostly moot,
+   because of point 1 introducing inference vars,
+   so the closure only ever sees the inference var, but should we fix 1, this will become a problem.
diff --git a/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
new file mode 100644
index 000000000..2be072dd2
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
@@ -0,0 +1,63 @@
+# Opaque types (type alias `impl Trait`)
+
+Opaque types are syntax to declare an opaque type alias that only
+exposes a specific set of traits as their interface; the concrete type in the
+background is inferred from a certain set of use sites of the opaque type.
+
+This is expressed by using `impl Trait` within type aliases, for example:
+
+```rust,ignore
+type Foo = impl Bar;
+```
+
+This declares an opaque type named `Foo`, of which the only information is that
+it implements `Bar`. Therefore, any of `Bar`'s interface can be used on a `Foo`,
+but nothing else (regardless of whether it implements any other traits).
+
+Since there needs to be a concrete background type, you can (as of <!-- date:
+2021-01 --> January 2021) express that type by using the opaque type in a
+"defining use site".
+
+```rust,ignore
+struct Struct;
+impl Bar for Struct { /* stuff */ }
+fn foo() -> Foo {
+    Struct
+}
+```
+
+Any other "defining use site" needs to produce the exact same type.
+
+## Defining use site(s)
+
+Currently only the return value of a function can be a defining use site
+of an opaque type (and only if the return type of that function contains
+the opaque type).
+
+The defining use of an opaque type can be any code *within* the parent
+of the opaque type definition. This includes any siblings of the
+opaque type and all children of the siblings.
+
+The initiative for *"not causing fatal brain damage to developers due to
+accidentally running infinite loops in their brain while trying to
+comprehend what the type system is doing"* has decided to disallow children
+of opaque types to be defining use sites.
+
+### Associated opaque types
+
+Associated opaque types can be defined by any other associated item
+on the same trait `impl` or a child of these associated items. For instance:
+
+```rust,ignore
+trait Baz {
+    type Foo;
+    fn foo() -> Self::Foo;
+}
+
+struct Quux;
+
+impl Baz for Quux {
+    type Foo = impl Bar;
+    fn foo() -> Self::Foo { ... }
+}
+```
diff --git a/src/doc/rustc-dev-guide/src/overview.md b/src/doc/rustc-dev-guide/src/overview.md
new file mode 100644
index 000000000..de6c88e7e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/overview.md
@@ -0,0 +1,423 @@
+# Overview of the Compiler
+
+<!-- toc -->
+
+This chapter is about the overall process of compiling a program -- how
+everything fits together.
+
+The Rust compiler is special in two ways: it does things to your code that
+other compilers don't do (e.g. borrow checking) and it has a lot of
+unconventional implementation choices (e.g. queries). We will talk about these
+in turn in this chapter, and in the rest of the guide, we will look at all the
+individual pieces in more detail.
+
+## What the compiler does to your code
+
+So first, let's look at what the compiler does to your code. For now, we will
+avoid mentioning how the compiler implements these steps except as needed;
+we'll talk about that later.
+
+### Invocation
+
+Compilation begins when a user writes a Rust source program in text
+and invokes the `rustc` compiler on it. The work that the compiler needs to
+perform is defined by command-line options. For example, it is possible to
+enable nightly features (`-Z` flags), perform `check`-only builds, or emit
+LLVM-IR rather than executable machine code. The `rustc` executable call may
+be indirect through the use of `cargo`.
+
+Command line argument parsing occurs in the [`rustc_driver`]. This crate
+defines the compile configuration that is requested by the user and passes it
+to the rest of the compilation process as a [`rustc_interface::Config`].
+
+### Lexing and parsing
+
+The raw Rust source text is analyzed by a low-level *lexer* located in
+[`rustc_lexer`]. At this stage, the source text is turned into a stream of
+atomic source code units known as _tokens_.  The lexer supports the
+Unicode character encoding.
+
+The token stream passes through a higher-level lexer located in
+[`rustc_parse`] to prepare for the next stage of the compile process. The
+[`StringReader`] struct is used at this stage to perform a set of validations
+and turn strings into interned symbols (_interning_ is discussed later).
+[String interning] is a way of storing only one immutable
+copy of each distinct string value.
+
+The lexer has a small interface and doesn't depend directly on the
+diagnostic infrastructure in `rustc`. Instead it provides diagnostics as plain
+data which are emitted in `rustc_parse::lexer` as real diagnostics.
+The lexer preserves full fidelity information for both IDEs and proc macros.
+
+The *parser* [translates the token stream from the lexer into an Abstract Syntax
+Tree (AST)][parser]. It uses a recursive descent (top-down) approach to syntax
+analysis. The crate entry points for the parser are the
+[`Parser::parse_crate_mod()`][parse_crate_mod] and [`Parser::parse_mod()`][parse_mod]
+methods found in [`rustc_parse::parser::Parser`]. The external module parsing
+entry point is [`rustc_expand::module::parse_external_mod`][parse_external_mod].
+And the macro parser entry point is [`Parser::parse_nonterminal()`][parse_nonterminal].
+
+Parsing is performed with a set of `Parser` utility methods including `bump`,
+`check`, `eat`, `expect`, `look_ahead`.
+
+Parsing is organized by semantic construct. Separate
+`parse_*` methods can be found in the [`rustc_parse`][rustc_parse_parser_dir]
+directory. The source file name follows the construct name. For example, the
+following files are found in the parser:
+
+- `expr.rs`
+- `pat.rs`
+- `ty.rs`
+- `stmt.rs`
+
+This naming scheme is used across many compiler stages. You will find
+either a file or directory with the same name across the parsing, lowering,
+type checking, THIR lowering, and MIR building sources.
+
+Macro expansion, AST validation, name resolution, and early linting also take place
+during this stage.
+
+The parser uses the standard `DiagnosticBuilder` API for error handling, but we
+try to recover, parsing a superset of Rust's grammar, while also emitting an error.
+`rustc_ast::ast::{Crate, Mod, Expr, Pat, ...}` AST nodes are returned from the parser.
+
+### HIR lowering
+
+Next, we take the AST and convert it to [High-Level Intermediate
+Representation (HIR)][hir], a more compiler-friendly representation of the
+AST. This process is called "lowering". It involves a lot of desugaring of things
+like loops and `async fn`.
+
+We then use the HIR to do [*type inference*] (the process of automatic
+detection of the type of an expression), [*trait solving*] (the process
+of pairing up an impl with each reference to a trait), and [*type
+checking*]. Type checking is the process of converting the types found in the HIR
+([`hir::Ty`]), which represent what the user wrote,
+into the internal representation used by the compiler ([`Ty<'tcx>`]).
+That information is used to verify the type safety, correctness and
+coherence of the types used in the program.
+
+### MIR lowering
+
+The HIR is then [lowered to Mid-level Intermediate Representation (MIR)][mir],
+which is used for [borrow checking].
+
+Along the way, we also construct the THIR, which is an even more desugared HIR.
+THIR is used for pattern and exhaustiveness checking. It is also more
+convenient to convert into MIR than HIR is.
+
+We do [many optimizations on the MIR][mir-opt] because it is still
+generic and that improves the code we generate later, improving compilation
+speed too.
+MIR is a higher level (and generic) representation, so it is easier to do
+some optimizations at MIR level than at LLVM-IR level. For example LLVM
+doesn't seem to be able to optimize the pattern the [`simplify_try`] mir
+opt looks for.
+
+Rust code is _monomorphized_, which means making copies of all the generic
+code with the type parameters replaced by concrete types. To do
+this, we need to collect a list of what concrete types to generate code for.
+This is called _monomorphization collection_ and it happens at the MIR level.
+
+### Code generation
+
+We then begin what is vaguely called _code generation_ or _codegen_.
+The [code generation stage][codegen] is when higher level
+representations of source are turned into an executable binary. `rustc`
+uses LLVM for code generation. The first step is to convert the MIR
+to LLVM Intermediate Representation (LLVM IR). This is where the MIR
+is actually monomorphized, according to the list we created in the
+previous step.
+The LLVM IR is passed to LLVM, which does a lot more optimizations on it.
+It then emits machine code. It is basically assembly code with additional
+low-level types and annotations added (e.g. an ELF object or WASM).
+The different libraries/binaries are then linked together to produce the final
+binary.
+
+[String interning]: https://en.wikipedia.org/wiki/String_interning
+[`rustc_lexer`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/index.html
+[`rustc_driver`]: rustc-driver.md
+[`rustc_interface::Config`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/struct.Config.html
+[lex]: the-parser.md
+[`StringReader`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.StringReader.html
+[`rustc_parse`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
+[parser]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
+[hir]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/index.html
+[*type inference*]: type-inference.md
+[*trait solving*]: traits/resolution.md
+[*type checking*]: type-checking.md
+[mir]: mir/index.md
+[borrow checking]: borrow_check.md
+[mir-opt]: mir/optimizations.md
+[`simplify_try`]: https://github.com/rust-lang/rust/pull/66282
+[codegen]: backend/codegen.md
+[parse_nonterminal]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html#method.parse_nonterminal
+[parse_crate_mod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html#method.parse_crate_mod
+[parse_mod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html#method.parse_mod
+[`rustc_parse::parser::Parser`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/struct.Parser.html
+[parse_external_mod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/module/fn.parse_external_mod.html
+[rustc_parse_parser_dir]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_parse/src/parser
+[`hir::Ty`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/struct.Ty.html
+[`Ty<'tcx>`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html
+
+## How it does it
+
+Ok, so now that we have a high-level view of what the compiler does to your
+code, let's take a high-level view of _how_ it does all that stuff. There are a
+lot of constraints and conflicting goals that the compiler needs to
+satisfy/optimize for. For example,
+
+- Compilation speed: how fast is it to compile a program. More/better
+  compile-time analyses often means compilation is slower.
+  - Also, we want to support incremental compilation, so we need to take that
+    into account. How can we keep track of what work needs to be redone and
+    what can be reused if the user modifies their program?
+    - Also we can't store too much stuff in the incremental cache because
+      it would take a long time to load from disk and it could take a lot
+      of space on the user's system...
+- Compiler memory usage: while compiling a program, we don't want to use more
+  memory than we need.
+- Program speed: how fast is your compiled program. More/better compile-time
+  analyses often means the compiler can do better optimizations.
+- Program size: how large is the compiled binary? Similar to the previous
+  point.
+- Compiler compilation speed: how long does it take to compile the compiler?
+  This impacts contributors and compiler maintenance.
+- Implementation complexity: building a compiler is one of the hardest
+  things a person/group can do, and Rust is not a very simple language, so how
+  do we make the compiler's code base manageable?
+- Compiler correctness: the binaries produced by the compiler should do what
+  the input programs says they do, and should continue to do so despite the
+  tremendous amount of change constantly going on.
+- Integration: a number of other tools need to use the compiler in
+  various ways (e.g. cargo, clippy, miri, RLS) that must be supported.
+- Compiler stability: the compiler should not crash or fail ungracefully on the
+  stable channel.
+- Rust stability: the compiler must respect Rust's stability guarantees by not
+  breaking programs that previously compiled despite the many changes that are
+  always going on to its implementation.
+- Limitations of other tools: rustc uses LLVM in its backend, and LLVM has some
+  strengths we leverage and some limitations/weaknesses we need to work around.
+
+So, as you read through the rest of the guide, keep these things in mind. They
+will often inform decisions that we make.
+
+### Intermediate representations
+
+As with most compilers, `rustc` uses some intermediate representations (IRs) to
+facilitate computations. In general, working directly with the source code is
+extremely inconvenient and error-prone. Source code is designed to be human-friendly while at
+the same time being unambiguous, but it's less convenient for doing something
+like, say, type checking.
+
+Instead most compilers, including `rustc`, build some sort of IR out of the
+source code which is easier to analyze. `rustc` has a few IRs, each optimized
+for different purposes:
+
+- Token stream: the lexer produces a stream of tokens directly from the source
+  code. This stream of tokens is easier for the parser to deal with than raw
+  text.
+- Abstract Syntax Tree (AST): the abstract syntax tree is built from the stream
+  of tokens produced by the lexer. It represents
+  pretty much exactly what the user wrote. It helps to do some syntactic sanity
+  checking (e.g. checking that a type is expected where the user wrote one).
+- High-level IR (HIR): This is a sort of desugared AST. It's still close
+  to what the user wrote syntactically, but it includes some implicit things
+  such as some elided lifetimes, etc. This IR is amenable to type checking.
+- Typed HIR (THIR): This is an intermediate between HIR and MIR, and used to be called
+  High-level Abstract IR (HAIR). It is like the HIR but it is fully typed and a bit
+  more desugared (e.g. method calls and implicit dereferences are made fully explicit).
+  Moreover, it is easier to lower to MIR from THIR than from HIR.
+- Middle-level IR (MIR): This IR is basically a Control-Flow Graph (CFG). A CFG
+  is a type of diagram that shows the basic blocks of a program and how control
+  flow can go between them. Likewise, MIR also has a bunch of basic blocks with
+  simple typed statements inside them (e.g. assignment, simple computations,
+  etc) and control flow edges to other basic blocks (e.g., calls, dropping
+  values). MIR is used for borrow checking and other
+  important dataflow-based checks, such as checking for uninitialized values.
+  It is also used for a series of optimizations and for constant evaluation (via
+  MIRI). Because MIR is still generic, we can do a lot of analyses here more
+  efficiently than after monomorphization.
+- LLVM IR: This is the standard form of all input to the LLVM compiler. LLVM IR
+  is a sort of typed assembly language with lots of annotations. It's
+  a standard format that is used by all compilers that use LLVM (e.g. the clang
+  C compiler also outputs LLVM IR). LLVM IR is designed to be easy for other
+  compilers to emit and also rich enough for LLVM to run a bunch of
+  optimizations on it.
+
+One other thing to note is that many values in the compiler are _interned_.
+This is a performance and memory optimization in which we allocate the values
+in a special allocator called an _arena_. Then, we pass around references to
+the values allocated in the arena. This allows us to make sure that identical
+values (e.g. types in your program) are only allocated once and can be compared
+cheaply by comparing pointers. Many of the intermediate representations are
+interned.
+
+### Queries
+
+The first big implementation choice is the _query_ system. The Rust compiler
+uses a query system which is unlike most textbook compilers, which are
+organized as a series of passes over the code that execute sequentially. The
+compiler does this to make incremental compilation possible -- that is, if the
+user makes a change to their program and recompiles, we want to do as little
+redundant work as possible to produce the new binary.
+
+In `rustc`, all the major steps above are organized as a bunch of queries that
+call each other. For example, there is a query to ask for the type of something
+and another to ask for the optimized MIR of a function. These
+queries can call each other and are all tracked through the query system.
+The results of the queries are cached on disk so that we can tell which
+queries' results changed from the last compilation and only redo those. This is
+how incremental compilation works.
+
+In principle, for the query-fied steps, we do each of the above for each item
+individually. For example, we will take the HIR for a function and use queries
+to ask for the LLVM IR for that HIR. This drives the generation of optimized
+MIR, which drives the borrow checker, which drives the generation of MIR, and
+so on.
+
+... except that this is very over-simplified. In fact, some queries are not
+cached on disk, and some parts of the compiler have to run for all code anyway
+for correctness even if the code is dead code (e.g. the borrow checker). For
+example, [currently the `mir_borrowck` query is first executed on all functions
+of a crate.][passes] Then the codegen backend invokes the
+`collect_and_partition_mono_items` query, which first recursively requests the
+`optimized_mir` for all reachable functions, which in turn runs `mir_borrowck`
+for that function and then creates codegen units. This kind of split will need
+to remain to ensure that unreachable functions still have their errors emitted.
+
+[passes]: https://github.com/rust-lang/rust/blob/45ebd5808afd3df7ba842797c0fcd4447ddf30fb/src/librustc_interface/passes.rs#L824
+
+Moreover, the compiler wasn't originally built to use a query system; the query
+system has been retrofitted into the compiler, so parts of it are not query-fied
+yet. Also, LLVM isn't our code, so that isn't querified either. The plan is to
+eventually query-fy all of the steps listed in the previous section,
+but as of <!-- date: 2021-11 --> November 2021, only the steps between HIR and
+LLVM IR are query-fied. That is, lexing, parsing, name resolution, and macro
+expansion are done all at once for the whole program.
+
+One other thing to mention here is the all-important "typing context",
+[`TyCtxt`], which is a giant struct that is at the center of all things.
+(Note that the name is mostly historic. This is _not_ a "typing context" in the
+sense of `Γ` or `Δ` from type theory. The name is retained because that's what
+the name of the struct is in the source code.) All
+queries are defined as methods on the [`TyCtxt`] type, and the in-memory query
+cache is stored there too. In the code, there is usually a variable called
+`tcx` which is a handle on the typing context. You will also see lifetimes with
+the name `'tcx`, which means that something is tied to the lifetime of the
+`TyCtxt` (usually it is stored or interned there).
+
+[`TyCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html
+
+### `ty::Ty`
+
+Types are really important in Rust, and they form the core of a lot of compiler
+analyses. The main type (in the compiler) that represents types (in the user's
+program) is [`rustc_middle::ty::Ty`][ty]. This is so important that we have a whole chapter
+on [`ty::Ty`][ty], but for now, we just want to mention that it exists and is the way
+`rustc` represents types!
+
+Also note that the `rustc_middle::ty` module defines the `TyCtxt` struct we mentioned before.
+
+[ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html
+
+### Parallelism
+
+Compiler performance is a problem that we would like to improve on
+(and are always working on). One aspect of that is parallelizing
+`rustc` itself.
+
+Currently, there is only one part of rustc that is parallel by default: codegen.
+
+However, the rest of the compiler is still not yet parallel. There have been
+lots of efforts spent on this, but it is generally a hard problem. The current
+approach is to turn `RefCell`s into `Mutex`s -- that is, we
+switch to thread-safe internal mutability. However, there are ongoing
+challenges with lock contention, maintaining query-system invariants under
+concurrency, and the complexity of the code base. One can try out the current
+work by enabling parallel compilation in `config.toml`. It's still early days,
+but there are already some promising performance improvements.
+
+### Bootstrapping
+
+`rustc` itself is written in Rust. So how do we compile the compiler? We use an
+older compiler to compile the newer compiler. This is called [_bootstrapping_].
+
+Bootstrapping has a lot of interesting implications. For example, it means
+that one of the major users of Rust is the Rust compiler, so we are
+constantly testing our own software ("eating our own dogfood").
+
+For more details on bootstrapping, see
+[the bootstrapping section of the guide][rustc-bootstrap].
+
+[_bootstrapping_]: https://en.wikipedia.org/wiki/Bootstrapping_(compilers)
+[rustc-bootstrap]: building/bootstrapping.md
+
+<!--
+# Unresolved Questions
+
+- Does LLVM ever do optimizations in debug builds?
+- How do I explore phases of the compile process in my own sources (lexer,
+  parser, HIR, etc)? - e.g., `cargo rustc -- -Z unpretty=hir-tree` allows you to
+  view HIR representation
+- What is the main source entry point for `X`?
+- Where do phases diverge for cross-compilation to machine code across
+  different platforms?
+-->
+
+# References
+
+- Command line parsing
+  - Guide: [The Rustc Driver and Interface](rustc-driver.md)
+  - Driver definition: [`rustc_driver`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/)
+  - Main entry point: [`rustc_session::config::build_session_options`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/config/fn.build_session_options.html)
+- Lexical Analysis: Lex the user program to a stream of tokens
+  - Guide: [Lexing and Parsing](the-parser.md)
+  - Lexer definition: [`rustc_lexer`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/index.html)
+  - Main entry point: [`rustc_lexer::first_token`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/fn.first_token.html)
+- Parsing: Parse the stream of tokens to an Abstract Syntax Tree (AST)
+  - Guide: [Lexing and Parsing](the-parser.md)
+  - Guide: [Macro Expansion](macro-expansion.md)
+  - Guide: [Name Resolution](name-resolution.md)
+  - Parser definition: [`rustc_parse`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html)
+  - Main entry points:
+    - [Entry point for first file in crate](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/passes/fn.parse.html)
+    - [Entry point for outline module parsing](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/module/fn.parse_external_mod.html)
+    - [Entry point for macro fragments][parse_nonterminal]
+  - AST definition: [`rustc_ast`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/index.html)
+  - Feature gating: **TODO**
+  - Early linting: **TODO**
+- The High Level Intermediate Representation (HIR)
+  - Guide: [The HIR](hir.md)
+  - Guide: [Identifiers in the HIR](hir.md#identifiers-in-the-hir)
+  - Guide: [The HIR Map](hir.md#the-hir-map)
+  - Guide: [Lowering AST to HIR](lowering.md)
+  - How to view HIR representation for your code `cargo rustc -- -Z unpretty=hir-tree`
+  - Rustc HIR definition: [`rustc_hir`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/index.html)
+  - Main entry point: **TODO**
+  - Late linting: **TODO**
+- Type Inference
+  - Guide: [Type Inference](type-inference.md)
+  - Guide: [The ty Module: Representing Types](ty.md) (semantics)
+  - Main entry point (type inference): [`InferCtxtBuilder::enter`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxtBuilder.html#method.enter)
+  - Main entry point (type checking bodies): [the `typeck` query](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.typeck)
+    - These two functions can't be decoupled.
+- The Mid Level Intermediate Representation (MIR)
+  - Guide: [The MIR (Mid level IR)](mir/index.md)
+  - Definition: [`rustc_middle/src/mir`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/index.html)
+  - Definition of sources that manipulates the MIR: [`rustc_mir_build`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/index.html), [`rustc_mir_dataflow`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_dataflow/index.html), [`rustc_mir_transform`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/index.html)
+- The Borrow Checker
+  - Guide: [MIR Borrow Check](borrow_check.md)
+  - Definition: [`rustc_borrowck`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/index.html)
+  - Main entry point: [`mir_borrowck` query](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_borrowck/fn.mir_borrowck.html)
+- MIR Optimizations
+  - Guide: [MIR Optimizations](mir/optimizations.md)
+  - Definition: [`rustc_mir_transform`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/index.html)
+  - Main entry point: [`optimized_mir` query](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_transform/fn.optimized_mir.html)
+- Code Generation
+  - Guide: [Code Generation](backend/codegen.md)
+  - Generating Machine Code from LLVM IR with LLVM - **TODO: reference?**
+  - Main entry point: [`rustc_codegen_ssa::base::codegen_crate`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/fn.codegen_crate.html)
+    - This monomorphizes and produces LLVM IR for one codegen unit. It then
+      starts a background thread to run LLVM, which must be joined later.
+    - Monomorphization happens lazily via [`FunctionCx::monomorphize`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/mir/struct.FunctionCx.html#method.monomorphize) and [`rustc_codegen_ssa::base::codegen_instance `](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/fn.codegen_instance.html)
diff --git a/src/doc/rustc-dev-guide/src/panic-implementation.md b/src/doc/rustc-dev-guide/src/panic-implementation.md
new file mode 100644
index 000000000..66e61548e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/panic-implementation.md
@@ -0,0 +1,112 @@
+# Panicking in rust
+
+<!-- toc -->
+
+## Step 1: Invocation of the `panic!` macro.
+
+There are actually two panic macros - one defined in `core`, and one defined in `std`.
+This is due to the fact that code in `core` can panic. `core` is built before `std`,
+but we want panics to use the same machinery at runtime, whether they originate in `core`
+or `std`.
+
+### core definition of panic!
+
+The `core` `panic!` macro eventually makes the following call (in `library/core/src/panicking.rs`):
+
+```rust
+// NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
+extern "Rust" {
+    #[lang = "panic_impl"]
+    fn panic_impl(pi: &PanicInfo<'_>) -> !;
+}
+
+let pi = PanicInfo::internal_constructor(Some(&fmt), location);
+unsafe { panic_impl(&pi) }
+```
+
+Actually resolving this goes through several layers of indirection:
+
+1. In `compiler/rustc_middle/src/middle/weak_lang_items.rs`, `panic_impl` is
+   declared as 'weak lang item', with the symbol `rust_begin_unwind`. This is
+   used in `rustc_typeck/src/collect.rs` to set the actual symbol name to
+   `rust_begin_unwind`.
+
+   Note that `panic_impl` is declared in an `extern "Rust"` block,
+   which means that core will attempt to call a foreign symbol called `rust_begin_unwind`
+   (to be resolved at link time)
+
+2. In `library/std/src/panicking.rs`, we have this definition:
+
+```rust
+/// Entry point of panic from the core crate.
+#[cfg(not(test))]
+#[panic_handler]
+#[unwind(allowed)]
+pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
+    ...
+}
+```
+
+The special `panic_handler` attribute is resolved via `compiler/rustc_middle/src/middle/lang_items`.
+The `extract` function converts the `panic_handler` attribute to a `panic_impl` lang item.
+
+Now, we have a matching `panic_handler` lang item in the `std`. This function goes
+through the same process as the `extern { fn panic_impl }` definition in `core`, ending
+up with a symbol name of `rust_begin_unwind`. At link time, the symbol reference in `core`
+will be resolved to the definition of `std` (the function called `begin_panic_handler` in the
+Rust source).
+
+Thus, control flow will pass from core to std at runtime. This allows panics from `core`
+to go through the same infrastructure that other panics use (panic hooks, unwinding, etc)
+
+### std implementation of panic!
+
+This is where the actual panic-related logic begins. In `library/std/src/panicking.rs`,
+control passes to `rust_panic_with_hook`. This method is responsible
+for invoking the global panic hook, and checking for double panics. Finally,
+we call `__rust_start_panic`, which is provided by the panic runtime.
+
+The call to `__rust_start_panic` is very weird - it is passed a `*mut &mut dyn BoxMeUp`,
+converted to an `usize`. Let's break this type down:
+
+1. `BoxMeUp` is an internal trait. It is implemented for `PanicPayload`
+(a wrapper around the user-supplied payload type), and has a method
+`fn box_me_up(&mut self) -> *mut (dyn Any + Send)`.
+This method takes the user-provided payload (`T: Any + Send`),
+boxes it, and converts the box to a raw pointer.
+
+2. When we call `__rust_start_panic`, we have an `&mut dyn BoxMeUp`.
+However, this is a fat pointer (twice the size of a `usize`).
+To pass this to the panic runtime across an FFI boundary, we take a mutable
+reference *to this mutable reference* (`&mut &mut dyn BoxMeUp`), and convert it to a raw pointer
+(`*mut &mut dyn BoxMeUp`). The outer raw pointer is a thin pointer, since it points to a `Sized`
+type (a mutable reference). Therefore, we can convert this thin pointer into a `usize`, which
+is suitable for passing across an FFI boundary.
+
+Finally, we call `__rust_start_panic` with this `usize`. We have now entered the panic runtime.
+
+## Step 2: The panic runtime
+
+Rust provides two panic runtimes: `panic_abort` and `panic_unwind`. The user chooses
+between them at build time via their `Cargo.toml`
+
+`panic_abort` is extremely simple: its implementation of `__rust_start_panic` just aborts,
+as you would expect.
+
+`panic_unwind` is the more interesting case.
+
+In its implementation of `__rust_start_panic`, we take the `usize`, convert
+it back to a `*mut &mut dyn BoxMeUp`, dereference it, and call `box_me_up`
+on the `&mut dyn BoxMeUp`. At this point, we have a raw pointer to the payload
+itself (a `*mut (dyn Send + Any)`): that is, a raw pointer to the actual value
+provided by the user who called `panic!`.
+
+At this point, the platform-independent code ends. We now call into
+platform-specific unwinding logic (e.g `unwind`). This code is
+responsible for unwinding the stack, running any 'landing pads' associated
+with each frame (currently, running destructors), and transferring control
+to the `catch_unwind` frame.
+
+Note that all panics either abort the process or get caught by some call to `catch_unwind`:
+in `library/std/src/rt.rs`, the call to the user-provided
+`main` function is wrapped in `catch_unwind`.
diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
new file mode 100644
index 000000000..4aa13d781
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -0,0 +1,106 @@
+# Parallel Compilation
+
+As of <!-- date: 2022-05 --> May 2022, The only stage of the compiler
+that is already parallel is codegen. The nightly compiler implements query evaluation,
+but there is still a lot of work to be done. The lack of parallelism at other stages
+also represents an opportunity for improving compiler performance. One can try out the current
+parallel compiler work by enabling it in the `config.toml`.
+
+These next few sections describe where and how parallelism is currently used,
+and the current status of making parallel compilation the default in `rustc`.
+
+The underlying thread-safe data-structures used in the parallel compiler
+can be found in the `rustc_data_structures::sync` module. Some of these data structures
+use the `parking_lot` crate as well.
+
+## Codegen
+
+There are two underlying thread safe data structures used in code generation:
+
+- `Lrc`
+    -  Which is an [`Arc`][Arc] if `parallel_compiler` is true, and a [`Rc`][Rc]
+       if it is not.
+- `MetadataRef` -> [`OwningRef<Box<dyn Erased + Send + Sync>, [u8]>`][OwningRef]
+    - This data structure is specific to `rustc`.
+
+During [monomorphization][monomorphization] the compiler splits up all the code to
+be generated into smaller chunks called _codegen units_. These are then generated by
+independent instances of LLVM running in parallel. At the end, the linker
+is run to combine all the codegen units together into one binary. This process
+occurs in the `rustc_codegen_ssa::base` module.
+
+## Query System
+
+The query model has some properties that make it actually feasible to evaluate
+multiple queries in parallel without too much of an effort:
+
+- All data a query provider can access is accessed via the query context, so
+  the query context can take care of synchronizing access.
+- Query results are required to be immutable so they can safely be used by
+  different threads concurrently.
+
+When a query `foo` is evaluated, the cache table for `foo` is locked.
+
+- If there already is a result, we can clone it, release the lock and
+  we are done.
+- If there is no cache entry and no other active query invocation computing the
+  same result, we mark the key as being "in progress", release the lock and
+  start evaluating.
+- If there *is* another query invocation for the same key in progress, we
+  release the lock, and just block the thread until the other invocation has
+  computed the result we are waiting for. This cannot deadlock because, as
+  mentioned before, query invocations form a DAG. Some threads will always make
+  progress.
+
+## Rustdoc
+
+As of <!-- date: 2022-05--> May 2022, there are still a number of steps
+to complete before rustdoc rendering can be made parallel. More details on
+this issue can be found [here][parallel-rustdoc].
+
+## Current Status
+
+As of <!-- date: 2022-05 --> May 2022, work on explicitly parallelizing the
+compiler has stalled. There is a lot of design and correctness work that needs
+to be done.
+
+These are the basic ideas in the effort to make `rustc` parallel:
+
+- There are a lot of loops in the compiler that just iterate over all items in
+  a crate. These can possibly be parallelized.
+- We can use (a custom fork of) [`rayon`] to run tasks in parallel. The custom
+  fork allows the execution of DAGs of tasks, not just trees.
+- There are currently a lot of global data structures that need to be made
+  thread-safe. A key strategy here has been converting interior-mutable
+  data-structures (e.g. `Cell`) into their thread-safe siblings (e.g. `Mutex`).
+
+[`rayon`]: https://crates.io/crates/rayon
+
+As of <!-- date: 2022-05 --> May 2022, much of this effort is on hold due
+to lack of manpower. We have a working prototype with promising performance
+gains in many cases. However, there are two blockers:
+
+- It's not clear what invariants need to be upheld that might not hold in the
+  face of concurrency. An auditing effort was underway, but seems to have
+  stalled at some point.
+
+- There is a lot of lock contention, which actually degrades performance as the
+  number of threads increases beyond 4.
+
+Here are some resources that can be used to learn more (note that some of them
+are a bit out of date):
+
+- [This IRLO thread by Zoxc, one of the pioneers of the effort][irlo0]
+- [This list of interior mutability in the compiler by nikomatsakis][imlist]
+- [This IRLO thread by alexchricton about performance][irlo1]
+- [This tracking issue][tracking]
+
+[irlo0]: https://internals.rust-lang.org/t/parallelizing-rustc-using-rayon/6606
+[imlist]: https://github.com/nikomatsakis/rustc-parallelization/blob/master/interior-mutability-list.md
+[irlo1]: https://internals.rust-lang.org/t/help-test-parallel-rustc/11503
+[tracking]: https://github.com/rust-lang/rust/issues/48685
+[monomorphization]: backend/monomorph.md
+[parallel-rustdoc]: https://github.com/rust-lang/rust/issues/82741
+[Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html
+[Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html
+[OwningRef]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/owning_ref/index.html
diff --git a/src/doc/rustc-dev-guide/src/param_env.md b/src/doc/rustc-dev-guide/src/param_env.md
new file mode 100644
index 000000000..08e19c339
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/param_env.md
@@ -0,0 +1,69 @@
+# Parameter Environment
+
+When working with associated and/or generic items (types, constants,
+functions/methods) it is often relevant to have more information about the
+`Self` or generic parameters. Trait bounds and similar information is encoded in
+the [`ParamEnv`][pe]. Often this is not enough information to obtain things like the
+type's `Layout`, but you can do all kinds of other checks on it (e.g. whether a
+type implements `Copy`) or you can evaluate an associated constant whose value
+does not depend on anything from the parameter environment.
+
+[pe]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamEnv.html
+
+For example if you have a function
+
+```rust
+fn foo<T: Copy>(t: T) { ... }
+```
+
+the parameter environment for that function is `[T: Copy]`. This means any
+evaluation within this function will, when accessing the type `T`, know about
+its `Copy` bound via the parameter environment.
+
+You can get the parameter environment for a `def_id` using the
+[`param_env`][query] query. However, this `ParamEnv` can be too generic for
+your use case. Using the `ParamEnv` from the surrounding context can allow you
+to evaluate more things. For example, suppose we had something the following:
+
+[query]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ty_utils/ty/fn.param_env.html
+
+```rust
+trait Foo {
+    type Assoc;
+}
+
+trait Bar { }
+
+trait Baz {
+    fn stuff() -> bool;
+}
+
+fn foo<T>(t: T)
+where
+    T: Foo,
+    <T as Foo>::Assoc: Bar
+{
+   bar::<T::Assoc>()
+}
+
+fn bar<T: Baz>() {
+    if T::stuff() { mep() } else { mop() }
+}
+```
+
+We may know some things inside `bar` that we wouldn't know if we just fetched
+`bar`'s param env because of the `<T as Foo>::Assoc: Bar` bound in `foo`. This
+is a contrived example that makes no sense in our existing analyses, but we may
+run into similar cases when doing analyses with associated constants on generic
+traits or traits with assoc types.
+
+## Bundling
+
+Another great thing about `ParamEnv` is that you can use it to bundle the thing
+depending on generic parameters (e.g. a `Ty`) by calling the [`and`][and]
+method. This will produce a [`ParamEnvAnd<Ty>`][pea], making clear that you
+should probably not be using the inner value without taking care to also use
+the [`ParamEnv`][pe].
+
+[and]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamEnv.html#method.and
+[pea]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamEnvAnd.html
diff --git a/src/doc/rustc-dev-guide/src/part-2-intro.md b/src/doc/rustc-dev-guide/src/part-2-intro.md
new file mode 100644
index 000000000..5ea4d7b6b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/part-2-intro.md
@@ -0,0 +1,14 @@
+# Part 2: High-Level Compiler Architecture
+
+The remaining parts of this guide discuss how the compiler works. They go
+through everything from high-level structure of the compiler to how each stage
+of compilation works. They should be friendly to both readers interested in the
+end-to-end process of compilation _and_ readers interested in learning about a
+specific system they wish to contribute to. If anything is unclear, feel free
+to file an issue on the [rustc-dev-guide
+repo](https://github.com/rust-lang/rustc-dev-guide/issues) or contact the compiler
+team, as detailed in [this chapter from Part 1](./compiler-team.md).
+
+In this part, we will look at the high-level architecture of the compiler. In
+particular, we will look at three overarching design choices that impact the
+whole compiler: the query system, incremental compilation, and interning.
diff --git a/src/doc/rustc-dev-guide/src/part-3-intro.md b/src/doc/rustc-dev-guide/src/part-3-intro.md
new file mode 100644
index 000000000..c10080632
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/part-3-intro.md
@@ -0,0 +1,10 @@
+# Part 3: Source Code Representation
+
+This part describes the process of taking raw source code from the user and
+transforming it into various forms that the compiler can work with easily.
+These are called _intermediate representations (IRs)_.
+
+This process starts with compiler understanding what the user has asked for:
+parsing the command line arguments given and determining what it is to compile.
+After that, the compiler transforms the user input into a series of IRs that
+look progressively less like what the user wrote.
diff --git a/src/doc/rustc-dev-guide/src/part-4-intro.md b/src/doc/rustc-dev-guide/src/part-4-intro.md
new file mode 100644
index 000000000..00a74f308
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/part-4-intro.md
@@ -0,0 +1,12 @@
+# Part 4: Analysis
+
+This part discusses the many analyses that the compiler uses to check various
+properties of the code and to inform later stages. Typically, this is what people
+mean when they talk about "Rust's type system". This includes the
+representation, inference, and checking of types, the trait system, and the
+borrow checker. These analyses do not happen as one big pass or set of
+contiguous passes. Rather, they are spread out throughout various parts of the
+compilation process and use different intermediate representations. For example,
+type checking happens on the HIR, while borrow checking happens on the MIR.
+Nonetheless, for the sake of presentation, we will discuss all of these
+analyses in this part of the guide.
diff --git a/src/doc/rustc-dev-guide/src/part-5-intro.md b/src/doc/rustc-dev-guide/src/part-5-intro.md
new file mode 100644
index 000000000..4b7c25797
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/part-5-intro.md
@@ -0,0 +1,54 @@
+# From MIR to Binaries
+
+All of the preceding chapters of this guide have one thing in common: we never
+generated any executable machine code at all! With this chapter, all of that
+changes.
+
+So far, we've shown how the compiler can take raw source code in text format
+and transform it into [MIR]. We have also shown how the compiler does various
+analyses on the code to detect things like type or lifetime errors. Now, we
+will finally take the MIR and produce some executable machine code.
+
+[MIR]: ./mir/index.md
+
+> NOTE: This part of a compiler is often called the _backend_. The term is a bit
+> overloaded because in the compiler source, it usually refers to the "codegen
+> backend" (i.e. LLVM or Cranelift). Usually, when you see the word "backend"
+> in this part, we are referring to the "codegen backend".
+
+So what do we need to do?
+
+0. First, we need to collect the set of things to generate code for. In
+   particular, we need to find out which concrete types to substitute for
+   generic ones, since we need to generate code for the concrete types.
+   Generating code for the concrete types (i.e. emitting a copy of the code for
+   each concrete type) is called _monomorphization_, so the process of
+   collecting all the concrete types is called _monomorphization collection_.
+1. Next, we need to actually lower the MIR to a codegen IR
+   (usually LLVM IR) for each concrete type we collected.
+2. Finally, we need to invoke LLVM or Cranelift, which runs a bunch of
+   optimization passes, generates executable code, and links together an
+   executable binary.
+
+[codegen1]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/fn.codegen_crate.html
+
+The code for codegen is actually a bit complex due to a few factors:
+
+- Support for multiple codegen backends (LLVM and Cranelift). We try to share as much
+  backend code between them as possible, so a lot of it is generic over the
+  codegen implementation. This means that there are often a lot of layers of
+  abstraction.
+- Codegen happens asynchronously in another thread for performance.
+- The actual codegen is done by a third-party library (either LLVM or Cranelift).
+
+Generally, the [`rustc_codegen_ssa`][ssa] crate contains backend-agnostic code
+(i.e. independent of LLVM or Cranelift), while the [`rustc_codegen_llvm`][llvm]
+crate contains code specific to LLVM codegen.
+
+[ssa]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/index.html
+[llvm]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_llvm/index.html
+
+At a very high level, the entry point is
+[`rustc_codegen_ssa::base::codegen_crate`][codegen1]. This function starts the
+process discussed in the rest of this chapter.
+
diff --git a/src/doc/rustc-dev-guide/src/pat-exhaustive-checking.md b/src/doc/rustc-dev-guide/src/pat-exhaustive-checking.md
new file mode 100644
index 000000000..a3103de8f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/pat-exhaustive-checking.md
@@ -0,0 +1,88 @@
+# Pattern and Exhaustiveness Checking
+
+In Rust, pattern matching and bindings have a few very helpful properties. The
+compiler will check that bindings are irrefutable when made and that match arms
+are exhaustive.
+
+## Pattern usefulness
+
+The central question that usefulness checking answers is:
+"in this match expression, is that branch reachable?".
+More precisely, it boils down to computing whether,
+given a list of patterns we have already seen,
+a given new pattern might match any new value.
+
+For example, in the following match expression,
+we ask in turn whether each pattern might match something
+that wasn't matched by the patterns above it.
+Here we see the 4th pattern is redundant with the 1st;
+that branch will get an "unreachable" warning.
+The 3rd pattern may or may not be useful,
+depending on whether `Foo` has other variants than `Bar`.
+Finally, we can ask whether the whole match is exhaustive
+by asking whether the wildcard pattern (`_`)
+is useful relative to the list of all the patterns in that match.
+Here we can see that `_` is useful (it would catch `(false, None)`);
+this expression would therefore get a "non-exhaustive match" error.
+
+```rust
+// x: (bool, Option<Foo>)
+match x {
+    (true, _) => {} // 1
+    (false, Some(Foo::Bar)) => {} // 2
+    (false, Some(_)) => {} // 3
+    (true, None) => {} // 4
+}
+```
+
+Thus usefulness is used for two purposes:
+detecting unreachable code (which is useful to the user),
+and ensuring that matches are exhaustive (which is important for soundness,
+because a match expression can return a value).
+
+## Where it happens
+
+This check is done to any expression that desugars to a match expression in MIR.
+That includes actual `match` expressions,
+but also anything that looks like pattern matching,
+including `if let`, destructuring `let`, and similar expressions.
+
+```rust
+// `match`
+// Usefulness can detect unreachable branches and forbid non-exhaustive matches.
+match foo() {
+    Ok(x) => x,
+    Err(_) => panic!(),
+}
+
+// `if let`
+// Usefulness can detect unreachable branches.
+if let Some(x) = foo() {
+    // ...
+}
+
+// `while let`
+// Usefulness can detect infinite loops and dead loops.
+while let Some(x) = it.next() {
+    // ...
+}
+
+// Destructuring `let`
+// Usefulness can forbid non-exhaustive patterns.
+let Foo::Bar(x, y) = foo();
+
+// Destructuring function arguments
+// Usefulness can forbid non-exhaustive patterns.
+fn foo(Foo { x, y }: Foo) {
+    // ...
+}
+```
+
+## The algorithm
+
+Exhaustiveness checking is implemented in [`check_match`].
+The core of the algorithm is in [`usefulness`].
+That file contains a detailed description of the algorithm.
+
+[`check_match`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/pattern/check_match/index.html
+[`usefulness`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/pattern/usefulness/index.html
diff --git a/src/doc/rustc-dev-guide/src/profile-guided-optimization.md b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
new file mode 100644
index 000000000..db2624e92
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
@@ -0,0 +1,140 @@
+# Profile Guided Optimization
+
+<!-- toc -->
+
+`rustc` supports doing profile-guided optimization (PGO).
+This chapter describes what PGO is and how the support for it is
+implemented in `rustc`.
+
+## What Is Profiled-Guided Optimization?
+
+The basic concept of PGO is to collect data about the typical execution of
+a program (e.g. which branches it is likely to take) and then use this data
+to inform optimizations such as inlining, machine-code layout,
+register allocation, etc.
+
+There are different ways of collecting data about a program's execution.
+One is to run the program inside a profiler (such as `perf`) and another
+is to create an instrumented binary, that is, a binary that has data
+collection built into it, and run that.
+The latter usually provides more accurate data.
+
+## How is PGO implemented in `rustc`?
+
+`rustc` current PGO implementation relies entirely on LLVM.
+LLVM actually [supports multiple forms][clang-pgo] of PGO:
+
+[clang-pgo]: https://clang.llvm.org/docs/UsersManual.html#profile-guided-optimization
+
+- Sampling-based PGO where an external profiling tool like `perf` is used
+  to collect data about a program's execution.
+- GCOV-based profiling, where code coverage infrastructure is used to collect
+  profiling information.
+- Front-end based instrumentation, where the compiler front-end (e.g. Clang)
+  inserts instrumentation intrinsics into the LLVM IR it generates (but see the
+  [^note-instrument-coverage]"Note").
+- IR-level instrumentation, where LLVM inserts the instrumentation intrinsics
+  itself during optimization passes.
+
+`rustc` supports only the last approach, IR-level instrumentation, mainly
+because it is almost exclusively implemented in LLVM and needs little
+maintenance on the Rust side. Fortunately, it is also the most modern approach,
+yielding the best results.
+
+So, we are dealing with an instrumentation-based approach, i.e. profiling data
+is generated by a specially instrumented version of the program that's being
+optimized. Instrumentation-based PGO has two components: a compile-time
+component and run-time component, and one needs to understand the overall
+workflow to see how they interact.
+
+[^note-instrument-coverage]: Note: `rustc` now supports front-end-based coverage
+instrumentation, via the experimental option
+[`-C instrument-coverage`](./llvm-coverage-instrumentation.md), but using these
+coverage results for PGO has not been attempted at this time.
+
+### Overall Workflow
+
+Generating a PGO-optimized program involves the following four steps:
+
+1. Compile the program with instrumentation enabled (e.g. `rustc -C profile-generate main.rs`)
+2. Run the instrumented program (e.g. `./main`) which generates a `default-<id>.profraw` file
+3. Convert the `.profraw` file into a `.profdata` file using LLVM's `llvm-profdata` tool.
+4. Compile the program again, this time making use of the profiling data
+   (e.g. `rustc -C profile-use=merged.profdata main.rs`)
+
+### Compile-Time Aspects
+
+Depending on which step in the above workflow we are in, two different things
+can happen at compile time:
+
+#### Create Binaries with Instrumentation
+
+As mentioned above, the profiling instrumentation is added by LLVM.
+`rustc` instructs LLVM to do so [by setting the appropriate][pgo-gen-passmanager]
+flags when creating LLVM `PassManager`s:
+
+```C
+	// `PMBR` is an `LLVMPassManagerBuilderRef`
+    unwrap(PMBR)->EnablePGOInstrGen = true;
+    // Instrumented binaries have a default output path for the `.profraw` file
+    // hard-coded into them:
+    unwrap(PMBR)->PGOInstrGen = PGOGenPath;
+```
+
+`rustc` also has to make sure that some of the symbols from LLVM's profiling
+runtime are not removed [by marking the with the right export level][pgo-gen-symbols].
+
+[pgo-gen-passmanager]: https://github.com/rust-lang/rust/blob/1.34.1/src/rustllvm/PassWrapper.cpp#L412-L416
+[pgo-gen-symbols]:https://github.com/rust-lang/rust/blob/1.34.1/src/librustc_codegen_ssa/back/symbol_export.rs#L212-L225
+
+
+#### Compile Binaries Where Optimizations Make Use Of Profiling Data
+
+In the final step of the workflow described above, the program is compiled
+again, with the compiler using the gathered profiling data in order to drive
+optimization decisions. `rustc` again leaves most of the work to LLVM here,
+basically [just telling][pgo-use-passmanager] the LLVM `PassManagerBuilder`
+where the profiling data can be found:
+
+```C
+	unwrap(PMBR)->PGOInstrUse = PGOUsePath;
+```
+
+[pgo-use-passmanager]: https://github.com/rust-lang/rust/blob/1.34.1/src/rustllvm/PassWrapper.cpp#L417-L420
+
+LLVM does the rest (e.g. setting branch weights, marking functions with
+`cold` or `inlinehint`, etc).
+
+
+### Runtime Aspects
+
+Instrumentation-based approaches always also have a runtime component, i.e.
+once we have an instrumented program, that program needs to be run in order
+to generate profiling data, and collecting and persisting this profiling
+data needs some infrastructure in place.
+
+In the case of LLVM, these runtime components are implemented in
+[compiler-rt][compiler-rt-profile] and statically linked into any instrumented
+binaries.
+The `rustc` version of this can be found in `library/profiler_builtins` which
+basically packs the C code from `compiler-rt` into a Rust crate.
+
+In order for `profiler_builtins` to be built, `profiler = true` must be set
+in `rustc`'s `config.toml`.
+
+[compiler-rt-profile]: https://github.com/llvm/llvm-project/tree/main/compiler-rt/lib/profile
+
+## Testing PGO
+
+Since the PGO workflow spans multiple compiler invocations most testing happens
+in [run-make tests][rmake-tests] (the relevant tests have `pgo` in their name).
+There is also a [codegen test][codegen-test] that checks that some expected
+instrumentation artifacts show up in LLVM IR.
+
+[rmake-tests]: https://github.com/rust-lang/rust/tree/master/src/test/run-make-fulldeps
+[codegen-test]: https://github.com/rust-lang/rust/blob/master/src/test/codegen/pgo-instrumentation.rs
+
+## Additional Information
+
+Clang's documentation contains a good overview on PGO in LLVM here:
+https://clang.llvm.org/docs/UsersManual.html#profile-guided-optimization
diff --git a/src/doc/rustc-dev-guide/src/profiling.md b/src/doc/rustc-dev-guide/src/profiling.md
new file mode 100644
index 000000000..ada497d88
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/profiling.md
@@ -0,0 +1,113 @@
+# Profiling the compiler
+
+This section talks about how to profile the compiler and find out where it spends its time.
+
+Depending on what you're trying to measure, there are several different approaches:
+
+- If you want to see if a PR improves or regresses compiler performance,
+  see the [rustc-perf chapter](tests/perf.md) for requesting a benchmarking run.
+
+- If you want a medium-to-high level overview of where `rustc` is spending its time:
+  - The `-Z self-profile` flag and [measureme](https://github.com/rust-lang/measureme) tools offer a query-based approach to profiling.
+    See [their docs](https://github.com/rust-lang/measureme/blob/master/summarize/README.md) for more information.
+
+- If you want function level performance data or even just more details than the above approaches:
+  - Consider using a native code profiler such as [perf](profiling/with_perf.md)
+  - or [tracy](https://github.com/nagisa/rust_tracy_client) for a nanosecond-precision,
+    full-featured graphical interface.
+
+- If you want a nice visual representation of the compile times of your crate graph,
+  you can use [cargo's `--timings` flag](https://doc.rust-lang.org/nightly/cargo/reference/timings.html),
+  e.g. `cargo build --timings`.
+  You can use this flag on the compiler itself with `CARGOFLAGS="--timings" ./x.py build`
+
+- If you want to profile memory usage, you can use various tools depending on what operating system
+  you are using.
+  - For Windows, read our [WPA guide](profiling/wpa_profiling.md).
+
+## Optimizing rustc's bootstrap times with `cargo-llvm-lines`
+
+Using [cargo-llvm-lines](https://github.com/dtolnay/cargo-llvm-lines) you can count the
+number of lines of LLVM IR across all instantiations of a generic function.
+Since most of the time compiling rustc is spent in LLVM, the idea is that by
+reducing the amount of code passed to LLVM, compiling rustc gets faster.
+
+To use `cargo-llvm-lines` together with somewhat custom rustc build process, you can use
+`-C save-temps` to obtain required LLVM IR. The option preserves temporary work products
+created during compilation. Among those is LLVM IR that represents an input to the
+optimization pipeline; ideal for our purposes. It is stored in files with `*.no-opt.bc`
+extension in LLVM bitcode format.
+
+Example usage:
+```
+cargo install cargo-llvm-lines
+# On a normal crate you could now run `cargo llvm-lines`, but `x.py` isn't normal :P
+
+# Do a clean before every run, to not mix in the results from previous runs.
+./x.py clean
+env RUSTFLAGS=-Csave-temps ./x.py build --stage 0 compiler/rustc
+
+# Single crate, e.g., rustc_middle. (Relies on the glob support of your shell.)
+# Convert unoptimized LLVM bitcode into a human readable LLVM assembly accepted by cargo-llvm-lines.
+for f in build/x86_64-unknown-linux-gnu/stage0-rustc/x86_64-unknown-linux-gnu/release/deps/rustc_middle-*.no-opt.bc; do
+  ./build/x86_64-unknown-linux-gnu/llvm/bin/llvm-dis "$f"
+done
+cargo llvm-lines --files ./build/x86_64-unknown-linux-gnu/stage0-rustc/x86_64-unknown-linux-gnu/release/deps/rustc_middle-*.ll > llvm-lines-middle.txt
+
+# Specify all crates of the compiler.
+for f in build/x86_64-unknown-linux-gnu/stage0-rustc/x86_64-unknown-linux-gnu/release/deps/*.no-opt.bc; do
+  ./build/x86_64-unknown-linux-gnu/llvm/bin/llvm-dis "$f"
+done
+cargo llvm-lines --files ./build/x86_64-unknown-linux-gnu/stage0-rustc/x86_64-unknown-linux-gnu/release/deps/*.ll > llvm-lines.txt
+```
+
+Example output for the compiler:
+```
+  Lines            Copies          Function name
+  -----            ------          -------------
+  45207720 (100%)  1583774 (100%)  (TOTAL)
+   2102350 (4.7%)   146650 (9.3%)  core::ptr::drop_in_place
+    615080 (1.4%)     8392 (0.5%)  std::thread::local::LocalKey<T>::try_with
+    594296 (1.3%)     1780 (0.1%)  hashbrown::raw::RawTable<T>::rehash_in_place
+    592071 (1.3%)     9691 (0.6%)  core::option::Option<T>::map
+    528172 (1.2%)     5741 (0.4%)  core::alloc::layout::Layout::array
+    466854 (1.0%)     8863 (0.6%)  core::ptr::swap_nonoverlapping_one
+    412736 (0.9%)     1780 (0.1%)  hashbrown::raw::RawTable<T>::resize
+    367776 (0.8%)     2554 (0.2%)  alloc::raw_vec::RawVec<T,A>::grow_amortized
+    367507 (0.8%)      643 (0.0%)  rustc_query_system::dep_graph::graph::DepGraph<K>::with_task_impl
+    355882 (0.8%)     6332 (0.4%)  alloc::alloc::box_free
+    354556 (0.8%)    14213 (0.9%)  core::ptr::write
+    354361 (0.8%)     3590 (0.2%)  core::iter::traits::iterator::Iterator::fold
+    347761 (0.8%)     3873 (0.2%)  rustc_middle::ty::context::tls::set_tlv
+    337534 (0.7%)     2377 (0.2%)  alloc::raw_vec::RawVec<T,A>::allocate_in
+    331690 (0.7%)     3192 (0.2%)  hashbrown::raw::RawTable<T>::find
+    328756 (0.7%)     3978 (0.3%)  rustc_middle::ty::context::tls::with_context_opt
+    326903 (0.7%)      642 (0.0%)  rustc_query_system::query::plumbing::try_execute_query
+```
+
+Since this doesn't seem to work with incremental compilation or `./x.py check`,
+you will be compiling rustc _a lot_.
+I recommend changing a few settings in `config.toml` to make it bearable:
+```
+[rust]
+# A debug build takes _a third_ as long on my machine,
+# but compiling more than stage0 rustc becomes unbearably slow.
+optimize = false
+
+# We can't use incremental anyway, so we disable it for a little speed boost.
+incremental = false
+# We won't be running it, so no point in compiling debug checks.
+debug = false
+
+# Using a single codegen unit gives less output, but is slower to compile.
+codegen-units = 0  # num_cpus
+```
+
+The llvm-lines output is affected by several options.
+`optimize = false` increases it from 2.1GB to 3.5GB and `codegen-units = 0` to 4.1GB.
+
+MIR optimizations have little impact. Compared to the default `RUSTFLAGS="-Z
+mir-opt-level=1"`, level 0 adds 0.3GB and level 2 removes 0.2GB.
+As of <!-- date: 2022-07 --> July 2022,
+inlining happens in LLVM and GCC codegen backends,
+missing only in the Cranelift one.
diff --git a/src/doc/rustc-dev-guide/src/profiling/with_perf.md b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
new file mode 100644
index 000000000..af30b4732
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
@@ -0,0 +1,331 @@
+# Profiling with perf
+
+This is a guide for how to profile rustc with [perf](https://perf.wiki.kernel.org/index.php/Main_Page).
+
+## Initial steps
+
+- Get a clean checkout of rust-lang/master, or whatever it is you want
+  to profile.
+- Set the following settings in your `config.toml`:
+  - `debuginfo-level = 1` - enables line debuginfo
+  - `jemalloc = false` - lets you do memory use profiling with valgrind
+  - leave everything else the defaults
+- Run `./x.py build` to get a full build
+- Make a rustup toolchain pointing to that result
+  - see [the "build and run" section for instructions][b-a-r]
+
+[b-a-r]: ../building/how-to-build-and-run.html#toolchain
+
+## Gathering a perf profile
+
+perf is an excellent tool on linux that can be used to gather and
+analyze all kinds of information. Mostly it is used to figure out
+where a program spends its time. It can also be used for other sorts
+of events, though, like cache misses and so forth.
+
+### The basics
+
+The basic `perf` command is this:
+
+```bash
+perf record -F99 --call-graph dwarf XXX
+```
+
+The `-F99` tells perf to sample at 99 Hz, which avoids generating too
+much data for longer runs (why 99 Hz you ask? It is often chosen
+because it is unlikely to be in lockstep with other periodic
+activity). The `--call-graph dwarf` tells perf to get call-graph
+information from debuginfo, which is accurate. The `XXX` is the
+command you want to profile. So, for example, you might do:
+
+```bash
+perf record -F99 --call-graph dwarf cargo +<toolchain> rustc
+```
+
+to run `cargo` -- here `<toolchain>` should be the name of the toolchain
+you made in the beginning. But there are some things to be aware of:
+
+- You probably don't want to profile the time spend building
+  dependencies. So something like `cargo build; cargo clean -p $C` may
+  be helpful (where `$C` is the crate name)
+    - Though usually I just do `touch src/lib.rs` and rebuild instead. =)
+- You probably don't want incremental messing about with your
+  profile. So something like `CARGO_INCREMENTAL=0` can be helpful.
+
+### Gathering a perf profile from a `perf.rust-lang.org` test
+
+Often we want to analyze a specific test from `perf.rust-lang.org`. To
+do that, the first step is to clone
+[the rustc-perf repository][rustc-perf-gh]:
+
+```bash
+git clone https://github.com/rust-lang/rustc-perf
+```
+
+[rustc-perf-gh]: https://github.com/rust-lang/rustc-perf
+
+#### Doing it the easy way
+
+Once you've cloned the repo, you can use the `collector` executable to
+do profiling for you! You can find
+[instructions in the rustc-perf readme][rustc-perf-readme].
+
+[rustc-perf-readme]: https://github.com/rust-lang/rustc-perf/blob/master/collector/README.md#profiling
+
+For example, to measure the clap-rs test, you might do:
+
+```bash
+./target/release/collector                                      \
+  --output-repo /path/to/place/output                           \
+  profile perf-record                                           \
+  --rustc /path/to/rustc/executable/from/your/build/directory   \
+  --cargo `which cargo`                                         \
+  --filter clap-rs                                              \
+  --builds Check                                                \
+```
+
+You can also use that same command to use cachegrind or other profiling tools.
+
+#### Doing it the hard way
+
+If you prefer to run things manually, that is also possible. You first
+need to find the source for the test you want. Sources for the tests
+are found in [the `collector/benchmarks` directory][dir]. So let's go
+into the directory of a specific test; we'll use `clap-rs` as an
+example:
+
+[dir]: https://github.com/rust-lang/rustc-perf/tree/master/collector/benchmarks
+
+```bash
+cd collector/benchmarks/clap-rs
+```
+
+In this case, let's say we want to profile the `cargo check`
+performance. In that case, I would first run some basic commands to
+build the dependencies:
+
+```bash
+# Setup: first clean out any old results and build the dependencies:
+cargo +<toolchain> clean
+CARGO_INCREMENTAL=0 cargo +<toolchain> check
+```
+
+(Again, `<toolchain>` should be replaced with the name of the
+toolchain we made in the first step.)
+
+Next: we want record the execution time for *just* the clap-rs crate,
+running cargo check. I tend to use `cargo rustc` for this, since it
+also allows me to add explicit flags, which we'll do later on.
+
+```bash
+touch src/lib.rs
+CARGO_INCREMENTAL=0 perf record -F99 --call-graph dwarf cargo rustc --profile check --lib
+```
+
+Note that final command: it's a doozy! It uses the `cargo rustc`
+command, which executes rustc with (potentially) additional options;
+the `--profile check` and `--lib` options specify that we are doing a
+`cargo check` execution, and that this is a library (not a binary).
+
+At this point, we can use `perf` tooling to analyze the results. For example:
+
+```bash
+perf report
+```
+
+will open up an interactive TUI program. In simple cases, that can be
+helpful. For more detailed examination, the [`perf-focus` tool][pf]
+can be helpful; it is covered below.
+
+**A note of caution.** Each of the rustc-perf tests is its own special
+  snowflake. In particular, some of them are not libraries, in which
+  case you would want to do `touch src/main.rs` and avoid passing
+  `--lib`. I'm not sure how best to tell which test is which to be
+  honest.
+
+### Gathering NLL data
+
+If you want to profile an NLL run, you can just pass extra options to
+the `cargo rustc` command, like so:
+
+```bash
+touch src/lib.rs
+CARGO_INCREMENTAL=0 perf record -F99 --call-graph dwarf cargo rustc --profile check --lib -- -Z borrowck=mir
+```
+
+[pf]: https://github.com/nikomatsakis/perf-focus
+
+## Analyzing a perf profile with `perf focus`
+
+Once you've gathered a perf profile, we want to get some information
+about it. For this, I personally use [perf focus][pf]. It's a kind of
+simple but useful tool that lets you answer queries like:
+
+- "how much time was spent in function F" (no matter where it was called from)
+- "how much time was spent in function F when it was called from G"
+- "how much time was spent in function F *excluding* time spent in G"
+- "what functions does F call and how much time does it spend in them"
+
+To understand how it works, you have to know just a bit about
+perf. Basically, perf works by *sampling* your process on a regular
+basis (or whenever some event occurs). For each sample, perf gathers a
+backtrace. `perf focus` lets you write a regular expression that tests
+which functions appear in that backtrace, and then tells you which
+percentage of samples had a backtrace that met the regular
+expression. It's probably easiest to explain by walking through how I
+would analyze NLL performance.
+
+### Installing `perf-focus`
+
+You can install perf-focus using `cargo install`:
+
+```bash
+cargo install perf-focus
+```
+
+### Example: How much time is spent in MIR borrowck?
+
+Let's say we've gathered the NLL data for a test. We'd like to know
+how much time it is spending in the MIR borrow-checker. The "main"
+function of the MIR borrowck is called `do_mir_borrowck`, so we can do
+this command:
+
+```bash
+$ perf focus '{do_mir_borrowck}'
+Matcher    : {do_mir_borrowck}
+Matches    : 228
+Not Matches: 542
+Percentage : 29%
+```
+
+The `'{do_mir_borrowck}'` argument is called the **matcher**. It
+specifies the test to be applied on the backtrace. In this case, the
+`{X}` indicates that there must be *some* function on the backtrace
+that meets the regular expression `X`. In this case, that regex is
+just the name of the function we want (in fact, it's a subset of the name;
+the full name includes a bunch of other stuff, like the module
+path). In this mode, perf-focus just prints out the percentage of
+samples where `do_mir_borrowck` was on the stack: in this case, 29%.
+
+**A note about c++filt.** To get the data from `perf`, `perf focus`
+  currently executes `perf script` (perhaps there is a better
+  way...). I've sometimes found that `perf script` outputs C++ mangled
+  names. This is annoying. You can tell by running `perf script |
+  head` yourself — if you see names like `5rustc6middle` instead of
+  `rustc::middle`, then you have the same problem. You can solve this
+  by doing:
+
+```bash
+perf script | c++filt | perf focus --from-stdin ...
+```
+
+This will pipe the output from `perf script` through `c++filt` and
+should mostly convert those names into a more friendly format. The
+`--from-stdin` flag to `perf focus` tells it to get its data from
+stdin, rather than executing `perf focus`. We should make this more
+convenient (at worst, maybe add a `c++filt` option to `perf focus`, or
+just always use it — it's pretty harmless).
+
+### Example: How much time does MIR borrowck spend solving traits?
+
+Perhaps we'd like to know how much time MIR borrowck spends in the
+trait checker. We can ask this using a more complex regex:
+
+```bash
+$ perf focus '{do_mir_borrowck}..{^rustc::traits}'
+Matcher    : {do_mir_borrowck},..{^rustc::traits}
+Matches    : 12
+Not Matches: 1311
+Percentage : 0%
+```
+
+Here we used the `..` operator to ask "how often do we have
+`do_mir_borrowck` on the stack and then, later, some function whose
+name begins with `rustc::traits`?" (basically, code in that module). It
+turns out the answer is "almost never" — only 12 samples fit that
+description (if you ever see *no* samples, that often indicates your
+query is messed up).
+
+If you're curious, you can find out exactly which samples by using the
+`--print-match` option. This will print out the full backtrace for
+each sample. The `|` at the front of the line indicates the part that
+the regular expression matched.
+
+### Example: Where does MIR borrowck spend its time?
+
+Often we want to do more "explorational" queries. Like, we know that
+MIR borrowck is 29% of the time, but where does that time get spent?
+For that, the `--tree-callees` option is often the best tool. You
+usually also want to give `--tree-min-percent` or
+`--tree-max-depth`. The result looks like this:
+
+```bash
+$ perf focus '{do_mir_borrowck}' --tree-callees --tree-min-percent 3
+Matcher    : {do_mir_borrowck}
+Matches    : 577
+Not Matches: 746
+Percentage : 43%
+
+Tree
+| matched `{do_mir_borrowck}` (43% total, 0% self)
+: | rustc_borrowck::nll::compute_regions (20% total, 0% self)
+: : | rustc_borrowck::nll::type_check::type_check_internal (13% total, 0% self)
+: : : | core::ops::function::FnOnce::call_once (5% total, 0% self)
+: : : : | rustc_borrowck::nll::type_check::liveness::generate (5% total, 3% self)
+: : : | <rustc_borrowck::nll::type_check::TypeVerifier<'a, 'b, 'tcx> as rustc::mir::visit::Visitor<'tcx>>::visit_mir (3% total, 0% self)
+: | rustc::mir::visit::Visitor::visit_mir (8% total, 6% self)
+: | <rustc_borrowck::MirBorrowckCtxt<'cx, 'tcx> as rustc_mir_dataflow::DataflowResultsConsumer<'cx, 'tcx>>::visit_statement_entry (5% total, 0% self)
+: | rustc_mir_dataflow::do_dataflow (3% total, 0% self)
+```
+
+What happens with `--tree-callees` is that
+
+- we find each sample matching the regular expression
+- we look at the code that is occurs *after* the regex match and try
+  to build up a call tree
+
+The `--tree-min-percent 3` option says "only show me things that take
+more than 3% of the time. Without this, the tree often gets really
+noisy and includes random stuff like the innards of
+malloc. `--tree-max-depth` can be useful too, it just limits how many
+levels we print.
+
+For each line, we display the percent of time in that function
+altogether ("total") and the percent of time spent in **just that
+function and not some callee of that function** (self). Usually
+"total" is the more interesting number, but not always.
+
+### Relative percentages
+
+By default, all in perf-focus are relative to the **total program
+execution**. This is useful to help you keep perspective — often as
+we drill down to find hot spots, we can lose sight of the fact that,
+in terms of overall program execution, this "hot spot" is actually not
+important. It also ensures that percentages between different queries
+are easily compared against one another.
+
+That said, sometimes it's useful to get relative percentages, so `perf
+focus` offers a `--relative` option. In this case, the percentages are
+listed only for samples that match (vs all samples). So for example we
+could get our percentages relative to the borrowck itself
+like so:
+
+```bash
+$ perf focus '{do_mir_borrowck}' --tree-callees --relative --tree-max-depth 1 --tree-min-percent 5
+Matcher    : {do_mir_borrowck}
+Matches    : 577
+Not Matches: 746
+Percentage : 100%
+
+Tree
+| matched `{do_mir_borrowck}` (100% total, 0% self)
+: | rustc_borrowck::nll::compute_regions (47% total, 0% self) [...]
+: | rustc::mir::visit::Visitor::visit_mir (19% total, 15% self) [...]
+: | <rustc_borrowck::MirBorrowckCtxt<'cx, 'tcx> as rustc_mir_dataflow::DataflowResultsConsumer<'cx, 'tcx>>::visit_statement_entry (13% total, 0% self) [...]
+: | rustc_mir_dataflow::do_dataflow (8% total, 1% self) [...]
+```
+
+Here you see that `compute_regions` came up as "47% total" — that
+means that 47% of `do_mir_borrowck` is spent in that function. Before,
+we saw 20% — that's because `do_mir_borrowck` itself is only 43% of
+the total time (and `.47 * .43 = .20`).
diff --git a/src/doc/rustc-dev-guide/src/profiling/wpa_profiling.md b/src/doc/rustc-dev-guide/src/profiling/wpa_profiling.md
new file mode 100644
index 000000000..e7cf9418c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/profiling/wpa_profiling.md
@@ -0,0 +1,108 @@
+# Profiling on Windows
+
+## Introducing WPR and WPA
+
+High-level performance analysis (including memory usage) can be performed with the Windows
+Performance Recorder (WPR) and Windows Performance Analyzer (WPA). As the names suggest, WPR is for
+recording system statistics (in the form of event trace log a.k.a. ETL files), while WPA is for
+analyzing these ETL files.
+
+WPR collects system wide statistics, so it won't just record things relevant to rustc but also
+everything else that's running on the machine. During analysis, we can filter to just the things we
+find interesting.
+
+These tools are quite powerful but also require a bit of learning
+before we can successfully profile the Rust compiler.
+
+Here we will explore how to use WPR and WPA for analyzing the Rust compiler as well as provide
+links to useful "profiles" (i.e., settings files that tweak the defaults for WPR and WPA) that are
+specifically designed to make analyzing rustc easier.
+
+### Installing WPR and WPA
+
+You can install WPR and WPA as part of the Windows Performance Toolkit which itself is an option as
+part of downloading the Windows Assessment and Deployment Kit (ADK). You can download the ADK
+installer [here](https://go.microsoft.com/fwlink/?linkid=2086042). Make sure to select the Windows
+Performance Toolkit (you don't need to select anything else).
+
+## Recording
+
+In order to perform system analysis, you'll first need to record your system with WPR. Open WPR and
+at the bottom of the window select the "profiles" of the things you want to record. For looking
+into memory usage of the rustc bootstrap process, we'll want to select the following items:
+
+* CPU usage
+* VirtualAlloc usage
+
+You might be tempted to record "Heap usage" as well, but this records every single heap allocation
+and can be very, very expensive. For high-level analysis, it might be best to leave that turned
+off.
+
+Now we need to get our setup ready to record. For memory usage analysis, it is best to record the
+stage 2 compiler build with a stage 1 compiler build with debug symbols. Having symbols in the
+compiler we're using to build rustc will aid our analysis greatly by allowing WPA to resolve Rust
+symbols correctly. Unfortunately, the stage 0 compiler does not have symbols turned on which is why
+we'll need to build a stage 1 compiler and then a stage 2 compiler ourselves.
+
+To do this, make sure you have set `debuginfo-level = 1` in your `config.toml` file. This tells
+rustc to generate debug information which includes stack frames when bootstrapping.
+
+Now you can build the stage 1 compiler: `python x.py build --stage 1 -i library` or however
+else you want to build the stage 1 compiler.
+
+Now that the stage 1 compiler is built, we can record the stage 2 build. Go back to WPR, click the
+"start" button and build the stage 2 compiler (e.g., `python x build --stage=2 -i library`).
+When this process finishes, stop the recording.
+
+Click the Save button and once that process is complete, click the "Open in WPA" button which
+appears.
+
+> Note: The trace file is fairly large so it can take WPA some time to finish opening the file.
+
+## Analysis
+
+Now that our ETL file is open in WPA, we can analyze the results. First, we'll want to apply the
+pre-made "profile" which will put WPA into a state conducive to analyzing rustc bootstrap. Download
+the profile [here](https://github.com/wesleywiser/rustc-bootstrap-wpa-analysis/releases/download/1/rustc.generic.wpaProfile).
+Select the "Profiles" menu at the top, then "apply" and then choose the downloaded profile.
+
+You should see something resembling the following:
+
+![WPA with profile applied](../img/wpa-initial-memory.png)
+
+Next, we will need to tell WPA to load and process debug symbols so that it can properly demangle
+the Rust stack traces. To do this, click "Trace" and then choose "Load Symbols". This step can take
+a while.
+
+Once WPA has loaded symbols for rustc, we can expand the rustc.exe node and begin drilling down
+into the stack with the largest allocations.
+
+To do that, we'll expand the `[Root]` node in the "Commit Stack" column and continue expanding
+until we find interesting stack frames.
+
+> Tip: After selecting the node you want to expand, press the right arrow key. This will expand the
+node and put the selection on the next largest node in the expanded set. You can continue pressing
+the right arrow key until you reach an interesting frame.
+
+![WPA with expanded stack](../img/wpa-stack.png)
+
+In this sample, you can see calls through codegen are allocating ~30gb of memory in total
+throughout this profile.
+
+## Other Analysis Tabs
+
+The profile also includes a few other tabs which can be helpful:
+
+- System Configuration
+    - General information about the system the capture was recorded on.
+- rustc Build Processes
+    - A flat list of relevant processes such as rustc.exe, cargo.exe, link.exe etc.
+    - Each process lists its command line arguments.
+    - Useful for figuring out what a specific rustc process was working on.
+- rustc Build Process Tree
+    - Timeline showing when processes started and exited.
+- rustc CPU Analysis
+    - Contains charts preconfigured to show hotspots in rustc.
+    - These charts are designed to support analyzing where rustc is spending its time.
+- rustc Memory Analysis
+    - Contains charts preconfigured to show where rustc is allocating memory.
diff --git a/src/doc/rustc-dev-guide/src/queries/example-0.counts.txt b/src/doc/rustc-dev-guide/src/queries/example-0.counts.txt
new file mode 100644
index 000000000..e5b9c3f3d
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/example-0.counts.txt
@@ -0,0 +1,104 @@
+translation,1,0.891
+symbol_name,2658,0.733
+def_symbol_name,2556,0.268
+item_attrs,5566,0.162
+type_of,6922,0.117
+generics_of,8020,0.084
+serialize dep graph,1,0.079
+relevant_trait_impls_for,50,0.063
+def_span,24875,0.061
+expansion,1,0.059
+const checking,1,0.055
+adt_def,1141,0.048
+trait_impls_of,32,0.045
+is_copy_raw,47,0.045
+is_foreign_item,2638,0.042
+fn_sig,2172,0.033
+adt_dtorck_constraint,2,0.023
+impl_trait_ref,2434,0.023
+typeck_tables_of,29,0.022
+item-bodies checking,1,0.017
+typeck_item_bodies,1,0.017
+is_default_impl,2320,0.017
+borrow checking,1,0.014
+borrowck,4,0.014
+mir_validated,4,0.013
+adt_destructor,10,0.012
+layout_raw,258,0.010
+load_dep_graph,1,0.007
+item-types checking,1,0.005
+mir_const,2,0.005
+name resolution,1,0.004
+is_object_safe,35,0.003
+is_sized_raw,89,0.003
+parsing,1,0.003
+is_freeze_raw,11,0.001
+privacy checking,1,0.001
+privacy_access_levels,5,0.001
+resolving dependency formats,1,0.001
+adt_sized_constraint,9,0.001
+wf checking,1,0.001
+liveness checking,1,0.001
+compute_incremental_hashes_map,1,0.001
+match checking,1,0.001
+type collecting,1,0.001
+param_env,31,0.000
+effect checking,1,0.000
+trait_def,140,0.000
+lowering ast -> hir,1,0.000
+predicates_of,70,0.000
+extern_crate,319,0.000
+lifetime resolution,1,0.000
+is_const_fn,6,0.000
+intrinsic checking,1,0.000
+translation item collection,1,0.000
+impl_polarity,15,0.000
+creating allocators,1,0.000
+language item collection,1,0.000
+crate injection,1,0.000
+early lint checks,1,0.000
+indexing hir,1,0.000
+maybe creating a macro crate,1,0.000
+coherence checking,1,0.000
+optimized_mir,6,0.000
+is_panic_runtime,33,0.000
+associated_item_def_ids,7,0.000
+needs_drop_raw,10,0.000
+lint checking,1,0.000
+complete gated feature checking,1,0.000
+stability index,1,0.000
+region_maps,11,0.000
+super_predicates_of,8,0.000
+coherent_trait,2,0.000
+AST validation,1,0.000
+loop checking,1,0.000
+static item recursion checking,1,0.000
+variances_of,11,0.000
+associated_item,5,0.000
+plugin loading,1,0.000
+looking for plugin registrar,1,0.000
+stability checking,1,0.000
+describe_def,15,0.000
+variance testing,1,0.000
+codegen unit partitioning,1,0.000
+looking for entry point,1,0.000
+checking for inline asm in case the target doesn't support it,1,0.000
+inherent_impls,1,0.000
+crate_inherent_impls,1,0.000
+trait_of_item,7,0.000
+crate_inherent_impls_overlap_check,1,0.000
+attribute checking,1,0.000
+internalize symbols,1,0.000
+impl wf inference,1,0.000
+death checking,1,0.000
+reachability checking,1,0.000
+reachable_set,1,0.000
+is_exported_symbol,3,0.000
+is_mir_available,2,0.000
+unused lib feature checking,1,0.000
+maybe building test harness,1,0.000
+recursion limit,1,0.000
+write allocator module,1,0.000
+assert dep graph,1,0.000
+plugin registration,1,0.000
+write metadata,1,0.000
diff --git a/src/doc/rustc-dev-guide/src/queries/example-0.html b/src/doc/rustc-dev-guide/src/queries/example-0.html
new file mode 100644
index 000000000..b196aaa83
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/example-0.html
@@ -0,0 +1,313330 @@
+<html>
+<head>
+<!-- <link rel="stylesheet" type="text/css" href="profile_queries.css"> -->
+<style>
+
+body {
+    font-family: sans-serif;
+    background: black;
+}
+.trace {
+    color: black;
+    display: inline-block;
+    border-style: solid;
+    border-color: red;
+    border-width: 1px;
+    border-radius: 5px;
+    padding: 0px;
+    margin: 1px;
+    font-size: 0px;
+}
+.miss {
+    border-color: red;
+    border-width: 1px;
+}
+.extent-0 {
+    padding: 2px;
+}
+.time-begin {
+    border-width: 4px;
+    font-size: 12px;
+    color: white;
+    border-color: #afa;
+}
+.important {
+    border-width: 3px;
+    font-size: 12px;
+    color: white;
+    border-color: #f77;
+}
+.hit {
+    padding: 0px;
+    border-color: blue;
+    border-width: 3px;
+}
+.eff {
+  color: #fff;
+  display: inline-block;
+}
+.frc {
+  color: #7f7;
+  display: inline-block;
+}
+.dur {
+  display: none
+}
+.frac-50 {
+  padding: 10px;
+  border-width: 10px;
+  font-size: 32px;
+}
+.frac-40 {
+  padding: 8px;
+  border-width: 8px;
+  font-size: 24px;
+}
+.frac-30 {
+  padding: 6px;
+  border-width: 6px;
+  font-size: 18px;
+}
+.frac-20 {
+  padding: 4px;
+  border-width: 6px;
+  font-size: 16px;
+}
+.frac-10 {
+  padding: 2px;
+  border-width: 6px;
+  font-size: 14px;
+}
+</style>
+</head>
+<body>
+<div class="trace depth-0 extent-0 time-begin  frac-001">
+<div class="eff">parsing</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">recursion limit</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">crate injection</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">plugin loading</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">plugin registration</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 important time-begin  frac-05">
+<div class="eff">expansion</div>
+<div class="dur">0.059</div>
+<div class="frc">5.2%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">maybe building test harness</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">maybe creating a macro crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">creating allocators</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">checking for inline asm in case the target doesn't support it</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">early lint checks</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">AST validation</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-001">
+<div class="eff">name resolution</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">complete gated feature checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">lowering ast -> hir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">indexing hir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">attribute checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">language item collection</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">lifetime resolution</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">looking for entry point</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">looking for plugin registrar</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">loop checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">static item recursion checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">compute_incremental_hashes_map</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-001">
+<div class="eff">load_dep_graph</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">stability index</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">stability checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-7 important time-begin  frac-0">
+<div class="eff">type collecting</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">impl wf inference</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-2 time-begin  frac-0">
+<div class="eff">coherence checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 crate_inherent_impls miss  frac-0">
+<div class="eff">crate_inherent_impls</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 crate_inherent_impls_overlap_check miss  frac-0">
+<div class="eff">crate_inherent_impls_overlap_check</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">variance testing</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-7 important time-begin  frac-0">
+<div class="eff">wf checking</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 region_maps miss  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 region_maps miss  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 time-begin  frac-001">
+<div class="eff">item-types checking</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-1 extent-37 important typeck_tables_of miss  frac-001">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-18 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-23 important trait_impls_of miss  frac-001">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important is_object_safe miss  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 super_predicates_of miss  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 associated_item_def_ids miss  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 super_predicates_of miss  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 super_predicates_of hit  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 associated_item_def_ids hit  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-18 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 important time-begin  frac-01">
+<div class="eff">item-bodies checking</div>
+<div class="dur">0.017</div>
+<div class="frc">1.5%</div>
+<div class="trace depth-1 extent-2 important typeck_item_bodies miss  frac-01">
+<div class="eff">typeck_item_bodies</div>
+<div class="dur">0.017</div>
+<div class="frc">1.5%</div>
+<div class="trace depth-2 extent-140 important typeck_tables_of miss  frac-01">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.017</div>
+<div class="frc">1.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 inherent_impls miss  frac-0">
+<div class="eff">inherent_impls</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 associated_item_def_ids miss  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 associated_item miss  frac-0">
+<div class="eff">associated_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 variances_of miss  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 associated_item hit  frac-0">
+<div class="eff">associated_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-3 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-5 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 variances_of miss  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-18 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-18 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-7 important adt_dtorck_constraint miss  frac-01">
+<div class="eff">adt_dtorck_constraint</div>
+<div class="dur">0.012</div>
+<div class="frc">1.1%</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-4 adt_dtorck_constraint miss  frac-001">
+<div class="eff">adt_dtorck_constraint</div>
+<div class="dur">0.011</div>
+<div class="frc">1.0%</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-5 adt_destructor miss  frac-001">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.011</div>
+<div class="frc">1.0%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 coherent_trait miss  frac-0">
+<div class="eff">coherent_trait</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-6 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-6 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-6 extent-61 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.011</div>
+<div class="frc">1.0%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-60 important trait_impls_of miss  frac-001">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.010</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-8 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-9 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-9 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-10 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-10 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-11 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-5 adt_destructor miss  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 coherent_trait hit  frac-0">
+<div class="eff">coherent_trait</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-61 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-55 important time-begin  frac-02">
+<div class="eff">const checking</div>
+<div class="dur">0.055</div>
+<div class="frc">4.8%</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 important is_copy_raw miss  frac-02">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.030</div>
+<div class="frc">2.6%</div>
+<div class="trace depth-2 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-02">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.030</div>
+<div class="frc">2.6%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-158 important trait_impls_of miss  frac-02">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.028</div>
+<div class="frc">2.5%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 extern_crate miss  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-001">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-8 important is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-001">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-10 important is_copy_raw miss  frac-001">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-10 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-7 important trait_impls_of miss  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important is_object_safe miss  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 super_predicates_of miss  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 associated_item_def_ids miss  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 super_predicates_of hit  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 associated_item_def_ids hit  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_const_fn miss  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 associated_item hit  frac-0">
+<div class="eff">associated_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-57 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_const_fn miss  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-2 is_copy_raw miss  frac-001">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-159 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 time-begin  frac-001">
+<div class="eff">privacy checking</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-1 extent-39 important privacy_access_levels miss  frac-001">
+<div class="eff">privacy_access_levels</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 describe_def miss  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 describe_def miss  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 describe_def miss  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 associated_item hit  frac-0">
+<div class="eff">associated_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 associated_item hit  frac-0">
+<div class="eff">associated_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 describe_def hit  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 describe_def miss  frac-0">
+<div class="eff">describe_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-5 time-begin  frac-0">
+<div class="eff">intrinsic checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-4 time-begin  frac-0">
+<div class="eff">effect checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-3 time-begin  frac-0">
+<div class="eff">match checking</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 time-begin  frac-0">
+<div class="eff">liveness checking</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-2 important time-begin  frac-01">
+<div class="eff">borrow checking</div>
+<div class="dur">0.014</div>
+<div class="frc">1.2%</div>
+<div class="trace depth-1 extent-75 important borrowck miss  frac-001">
+<div class="eff">borrowck</div>
+<div class="dur">0.006</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-8 important mir_validated miss  frac-001">
+<div class="eff">mir_validated</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-46 important mir_const miss  frac-001">
+<div class="eff">mir_const</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw hit  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-3 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw hit  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 needs_drop_raw hit  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-3 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 variances_of hit  frac-0">
+<div class="eff">variances_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 is_const_fn miss  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_const_fn hit  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_const_fn hit  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-13 important borrowck miss  frac-001">
+<div class="eff">borrowck</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-27 important mir_validated miss  frac-001">
+<div class="eff">mir_validated</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-8 important mir_const miss  frac-0">
+<div class="eff">mir_const</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 region_maps hit  frac-0">
+<div class="eff">region_maps</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-67 important relevant_trait_impls_for miss  frac-001">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-66 important trait_impls_of miss  frac-001">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-001">
+<div class="eff">adt_def</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-6 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-7 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-7 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-8 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-8 important is_object_safe miss  frac-001">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 super_predicates_of miss  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 associated_item_def_ids miss  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 super_predicates_of hit  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 associated_item_def_ids hit  frac-0">
+<div class="eff">associated_item_def_ids</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-67 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 time-begin  frac-0">
+<div class="eff">reachability checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-1 reachable_set miss  frac-0">
+<div class="eff">reachable_set</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 privacy_access_levels hit  frac-0">
+<div class="eff">privacy_access_levels</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-0 extent-3 time-begin  frac-0">
+<div class="eff">death checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 privacy_access_levels hit  frac-0">
+<div class="eff">privacy_access_levels</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-1 time-begin  frac-0">
+<div class="eff">unused lib feature checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 privacy_access_levels hit  frac-0">
+<div class="eff">privacy_access_levels</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-11 important time-begin  frac-0">
+<div class="eff">lint checking</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-0 privacy_access_levels hit  frac-0">
+<div class="eff">privacy_access_levels</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-2 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-2 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 typeck_tables_of hit  frac-0">
+<div class="eff">typeck_tables_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-22 important time-begin  frac-0">
+<div class="eff">resolving dependency formats</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 is_panic_runtime miss  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-10589 important time-begin  frac-50">
+<div class="eff">translation</div>
+<div class="dur">0.891</div>
+<div class="frc">78.1%</div>
+<div class="trace depth-1 extent-0 time-begin  frac-0">
+<div class="eff">write metadata</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-31 important time-begin  frac-0">
+<div class="eff">translation item collection</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-23 important optimized_mir miss  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 borrowck hit  frac-0">
+<div class="eff">borrowck</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 mir_validated hit  frac-0">
+<div class="eff">mir_validated</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 param_env hit  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_copy_raw miss  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_copy_raw hit  frac-0">
+<div class="eff">is_copy_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_destructor hit  frac-0">
+<div class="eff">adt_destructor</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_const_fn hit  frac-0">
+<div class="eff">is_const_fn</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 trait_of_item miss  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 is_exported_symbol miss  frac-0">
+<div class="eff">is_exported_symbol</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_mir_available miss  frac-0">
+<div class="eff">is_mir_available</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 trait_of_item miss  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 is_exported_symbol miss  frac-0">
+<div class="eff">is_exported_symbol</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_exported_symbol hit  frac-0">
+<div class="eff">is_exported_symbol</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_foreign_item hit  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_mir_available hit  frac-0">
+<div class="eff">is_mir_available</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-8 important optimized_mir miss  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 trait_of_item miss  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 needs_drop_raw miss  frac-0">
+<div class="eff">needs_drop_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-3 optimized_mir miss  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 borrowck hit  frac-0">
+<div class="eff">borrowck</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 mir_validated hit  frac-0">
+<div class="eff">mir_validated</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-4 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_foreign_item hit  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-10 important time-begin  frac-0">
+<div class="eff">codegen unit partitioning</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-1 trait_of_item miss  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-17 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-10 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-21 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-43 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_polarity hit  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-13 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-4 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-4 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-21 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 adt_sized_constraint hit  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-4 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-28 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 extern_crate miss  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-3 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-5 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-14 important layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-11 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-3 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-121 important is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 relevant_trait_impls_for hit  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 predicates_of hit  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-6 important relevant_trait_impls_for miss  frac-0">
+<div class="eff">relevant_trait_impls_for</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_impls_of hit  frac-0">
+<div class="eff">trait_impls_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 is_object_safe hit  frac-0">
+<div class="eff">is_object_safe</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 impl_polarity miss  frac-0">
+<div class="eff">impl_polarity</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-35 important layout_raw miss  frac-001">
+<div class="eff">layout_raw</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-3 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-21 important layout_raw miss  frac-001">
+<div class="eff">layout_raw</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-4 param_env miss  frac-0">
+<div class="eff">param_env</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 super_predicates_of hit  frac-0">
+<div class="eff">super_predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-2 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-3 layout_raw miss  frac-001">
+<div class="eff">layout_raw</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 optimized_mir hit  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_freeze_raw hit  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_freeze_raw hit  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-4 adt_sized_constraint miss  frac-0">
+<div class="eff">adt_sized_constraint</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 predicates_of miss  frac-0">
+<div class="eff">predicates_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 optimized_mir hit  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-3 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 trait_of_item hit  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_freeze_raw hit  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_freeze_raw hit  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 trait_of_item hit  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 extern_crate hit  frac-0">
+<div class="eff">extern_crate</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_foreign_item hit  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 trait_of_item miss  frac-0">
+<div class="eff">trait_of_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 optimized_mir hit  frac-0">
+<div class="eff">optimized_mir</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-1 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_freeze_raw miss  frac-0">
+<div class="eff">is_freeze_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 layout_raw miss  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw miss  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 fn_sig hit  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 layout_raw hit  frac-0">
+<div class="eff">layout_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_sized_raw hit  frac-0">
+<div class="eff">is_sized_raw</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_foreign_item hit  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-01">
+<div class="eff">symbol_name</div>
+<div class="dur">0.017</div>
+<div class="frc">1.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-001">
+<div class="eff">fn_sig</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-02">
+<div class="eff">symbol_name</div>
+<div class="dur">0.025</div>
+<div class="frc">2.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-001">
+<div class="eff">fn_sig</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-01">
+<div class="eff">symbol_name</div>
+<div class="dur">0.012</div>
+<div class="frc">1.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 important item_attrs miss  frac-01">
+<div class="eff">item_attrs</div>
+<div class="dur">0.012</div>
+<div class="frc">1.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.010</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.010</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-6 important type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-5 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 important symbol_name miss  frac-01">
+<div class="eff">symbol_name</div>
+<div class="dur">0.020</div>
+<div class="frc">1.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-001">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-001">
+<div class="eff">fn_sig</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-001">
+<div class="eff">adt_def</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-001">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-11 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-15 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 trait_def miss  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-4 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-5 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-001">
+<div class="eff">adt_def</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-01">
+<div class="eff">symbol_name</div>
+<div class="dur">0.012</div>
+<div class="frc">1.0%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 important def_symbol_name miss  frac-01">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.012</div>
+<div class="frc">1.0%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.010</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.011</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.011</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-001">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-15 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-001">
+<div class="eff">adt_def</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-10 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-001">
+<div class="eff">fn_sig</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-001">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.010</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.010</div>
+<div class="frc">0.9%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-001">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-15 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-001">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-001">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.003</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.009</div>
+<div class="frc">0.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-11 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-01">
+<div class="eff">symbol_name</div>
+<div class="dur">0.021</div>
+<div class="frc">1.8%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 important item_attrs miss  frac-01">
+<div class="eff">item_attrs</div>
+<div class="dur">0.021</div>
+<div class="frc">1.8%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-001">
+<div class="eff">fn_sig</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.003</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-001">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.004</div>
+<div class="frc">0.3%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-8 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.005</div>
+<div class="frc">0.5%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-001">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.007</div>
+<div class="frc">0.6%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-8 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-001">
+<div class="eff">item_attrs</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-7 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-10 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-9 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-4 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 trait_def hit  frac-0">
+<div class="eff">trait_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-3 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-001">
+<div class="eff">def_span</div>
+<div class="dur">0.008</div>
+<div class="frc">0.7%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.005</div>
+<div class="frc">0.4%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-02">
+<div class="eff">symbol_name</div>
+<div class="dur">0.024</div>
+<div class="frc">2.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 important def_symbol_name miss  frac-02">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.024</div>
+<div class="frc">2.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-3 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-11 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-0 is_panic_runtime hit  frac-0">
+<div class="eff">is_panic_runtime</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-5 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-6 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.001</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.006</div>
+<div class="frc">0.5%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-001">
+<div class="eff">symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-001">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-001">
+<div class="eff">type_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.2%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-2 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-2 adt_def miss  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-5 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-001">
+<div class="eff">generics_of</div>
+<div class="dur">0.002</div>
+<div class="frc">0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-5 symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-5 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-2 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-4 extent-0 adt_def hit  frac-0">
+<div class="eff">adt_def</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-6 important def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 is_default_impl hit  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 type_of hit  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-0 impl_trait_ref hit  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-1 generics_of miss  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span miss  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-6 important symbol_name miss  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-1 item_attrs miss  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 is_foreign_item miss  frac-0">
+<div class="eff">is_foreign_item</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-1 fn_sig miss  frac-0">
+<div class="eff">fn_sig</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-2 extent-4 def_symbol_name miss  frac-0">
+<div class="eff">def_symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-3 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-3 extent-1 is_default_impl miss  frac-0">
+<div class="eff">is_default_impl</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 type_of miss  frac-0">
+<div class="eff">type_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-3 extent-1 impl_trait_ref miss  frac-0">
+<div class="eff">impl_trait_ref</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-4 extent-0 def_span hit  frac-0">
+<div class="eff">def_span</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-1 extent-5 time-begin  frac-0">
+<div class="eff">internalize symbols</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+<div class="trace depth-2 extent-0 generics_of hit  frac-0">
+<div class="eff">generics_of</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 symbol_name hit  frac-0">
+<div class="eff">symbol_name</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-2 extent-0 item_attrs hit  frac-0">
+<div class="eff">item_attrs</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-1 extent-0 time-begin  frac-0">
+<div class="eff">write allocator module</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+</div>
+<div class="trace depth-0 extent-0 time-begin  frac-0">
+<div class="eff">assert dep graph</div>
+<div class="dur">0.000</div>
+<div class="frc">< 0.1%</div>
+</div>
+<div class="trace depth-0 extent-0 important time-begin  frac-05">
+<div class="eff">serialize dep graph</div>
+<div class="dur">0.079</div>
+<div class="frc">6.9%</div>
+</div>
+</body>
+</html>
diff --git a/src/doc/rustc-dev-guide/src/queries/example-0.png b/src/doc/rustc-dev-guide/src/queries/example-0.png
new file mode 100644
index 000000000..14b46c44f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/example-0.png
diff --git a/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
new file mode 100644
index 000000000..dc196e490
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/incremental-compilation-in-detail.md
@@ -0,0 +1,537 @@
+# Incremental Compilation In Detail
+
+<!-- toc -->
+
+The incremental compilation scheme is, in essence, a surprisingly
+simple extension to the overall query system. It relies on the fact that:
+
+  1. queries are pure functions -- given the same inputs, a query will always
+     yield the same result, and
+  2. the query model structures compilation in an acyclic graph that makes
+     dependencies between individual computations explicit.
+
+This chapter will explain how we can use these properties for making things
+incremental and then goes on to discuss version implementation issues.
+
+## A Basic Algorithm For Incremental Query Evaluation
+
+As explained in the [query evaluation model primer][query-model], query
+invocations form a directed-acyclic graph. Here's the example from the
+previous chapter again:
+
+```ignore
+  list_of_all_hir_items <----------------------------- type_check_crate()
+                                                               |
+                                                               |
+  Hir(foo) <--- type_of(foo) <--- type_check_item(foo) <-------+
+                                      |                        |
+                    +-----------------+                        |
+                    |                                          |
+                    v                                          |
+  Hir(bar) <--- type_of(bar) <--- type_check_item(bar) <-------+
+```
+
+Since every access from one query to another has to go through the query
+context, we can record these accesses and thus actually build this dependency
+graph in memory. With dependency tracking enabled, when compilation is done,
+we know which queries were invoked (the nodes of the graph) and for each
+invocation, which other queries or input has gone into computing the query's
+result (the edges of the graph).
+
+Now suppose we change the source code of our program so that
+HIR of `bar` looks different than before. Our goal is to only recompute
+those queries that are actually affected by the change while re-using
+the cached results of all the other queries. Given the dependency graph we can
+do exactly that. For a given query invocation, the graph tells us exactly
+what data has gone into computing its results, we just have to follow the
+edges until we reach something that has changed. If we don't encounter
+anything that has changed, we know that the query still would evaluate to
+the same result we already have in our cache.
+
+Taking the `type_of(foo)` invocation from above as an example, we can check
+whether the cached result is still valid by following the edges to its
+inputs. The only edge leads to `Hir(foo)`, an input that has not been affected
+by the change. So we know that the cached result for `type_of(foo)` is still
+valid.
+
+The story is a bit different for `type_check_item(foo)`: We again walk the
+edges and already know that `type_of(foo)` is fine. Then we get to
+`type_of(bar)` which we have not checked yet, so we walk the edges of
+`type_of(bar)` and encounter `Hir(bar)` which *has* changed. Consequently
+the result of `type_of(bar)` might yield a different result than what we
+have in the cache and, transitively, the result of `type_check_item(foo)`
+might have changed too. We thus re-run `type_check_item(foo)`, which in
+turn will re-run `type_of(bar)`, which will yield an up-to-date result
+because it reads the up-to-date version of `Hir(bar)`.
+
+
+## The Problem With The Basic Algorithm: False Positives
+
+If you read the previous paragraph carefully you'll notice that it says that
+`type_of(bar)` *might* have changed because one of its inputs has changed.
+There's also the possibility that it might still yield exactly the same
+result *even though* its input has changed. Consider an example with a
+simple query that just computes the sign of an integer:
+
+```ignore
+  IntValue(x) <---- sign_of(x) <--- some_other_query(x)
+```
+
+Let's say that `IntValue(x)` starts out as `1000` and then is set to `2000`.
+Even though `IntValue(x)` is different in the two cases, `sign_of(x)` yields
+the result `+` in both cases.
+
+If we follow the basic algorithm, however, `some_other_query(x)` would have to
+(unnecessarily) be re-evaluated because it transitively depends on a changed
+input. Change detection yields a "false positive" in this case because it has
+to conservatively assume that `some_other_query(x)` might be affected by that
+changed input.
+
+Unfortunately it turns out that the actual queries in the compiler are full
+of examples like this and small changes to the input often potentially affect
+very large parts of the output binaries. As a consequence, we had to make the
+change detection system smarter and more accurate.
+
+## Improving Accuracy: The red-green Algorithm
+
+The "false positives" problem can be solved by interleaving change detection
+and query re-evaluation. Instead of walking the graph all the way to the
+inputs when trying to find out if some cached result is still valid, we can
+check if a result has *actually* changed after we were forced to re-evaluate
+it.
+
+We call this algorithm the red-green algorithm because nodes
+in the dependency graph are assigned the color green if we were able to prove
+that its cached result is still valid and the color red if the result has
+turned out to be different after re-evaluating it.
+
+The meat of red-green change tracking is implemented in the try-mark-green
+algorithm, that, you've guessed it, tries to mark a given node as green:
+
+```rust,ignore
+fn try_mark_green(tcx, current_node) -> bool {
+
+    // Fetch the inputs to `current_node`, i.e. get the nodes that the direct
+    // edges from `node` lead to.
+    let dependencies = tcx.dep_graph.get_dependencies_of(current_node);
+
+    // Now check all the inputs for changes
+    for dependency in dependencies {
+
+        match tcx.dep_graph.get_node_color(dependency) {
+            Green => {
+                // This input has already been checked before and it has not
+                // changed; so we can go on to check the next one
+            }
+            Red => {
+                // We found an input that has changed. We cannot mark
+                // `current_node` as green without re-running the
+                // corresponding query.
+                return false
+            }
+            Unknown => {
+                // This is the first time we look at this node. Let's try
+                // to mark it green by calling try_mark_green() recursively.
+                if try_mark_green(tcx, dependency) {
+                    // We successfully marked the input as green, on to the
+                    // next.
+                } else {
+                    // We could *not* mark the input as green. This means we
+                    // don't know if its value has changed. In order to find
+                    // out, we re-run the corresponding query now!
+                    tcx.run_query_for(dependency);
+
+                    // Fetch and check the node color again. Running the query
+                    // has forced it to either red (if it yielded a different
+                    // result than we have in the cache) or green (if it
+                    // yielded the same result).
+                    match tcx.dep_graph.get_node_color(dependency) {
+                        Red => {
+                            // The input turned out to be red, so we cannot
+                            // mark `current_node` as green.
+                            return false
+                        }
+                        Green => {
+                            // Re-running the query paid off! The result is the
+                            // same as before, so this particular input does
+                            // not invalidate `current_node`.
+                        }
+                        Unknown => {
+                            // There is no way a node has no color after
+                            // re-running the query.
+                            panic!("unreachable")
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // If we have gotten through the entire loop, it means that all inputs
+    // have turned out to be green. If all inputs are unchanged, it means
+    // that the query result corresponding to `current_node` cannot have
+    // changed either.
+    tcx.dep_graph.mark_green(current_node);
+
+    true
+}
+
+// Note: The actual implementation can be found in
+//       compiler/rustc_middle/src/dep_graph/graph.rs
+```
+
+By using red-green marking we can avoid the devastating cumulative effect of
+having false positives during change detection. Whenever a query is executed
+in incremental mode, we first check if its already green. If not, we run
+`try_mark_green()` on it. If it still isn't green after that, then we actually
+invoke the query provider to re-compute the result.
+
+
+
+## The Real World: How Persistence Makes Everything Complicated
+
+The sections above described the underlying algorithm for incremental
+compilation but because the compiler process exits after being finished and
+takes the query context with its result cache with it into oblivion, we have to
+persist data to disk, so the next compilation session can make use of it.
+This comes with a whole new set of implementation challenges:
+
+- The query result cache is stored to disk, so they are not readily available
+  for change comparison.
+- A subsequent compilation session will start off with new version of the code
+  that has arbitrary changes applied to it. All kinds of IDs and indices that
+  are generated from a global, sequential counter (e.g. `NodeId`, `DefId`, etc)
+  might have shifted, making the persisted results on disk not immediately
+  usable anymore because the same numeric IDs and indices might refer to
+  completely new things in the new compilation session.
+- Persisting things to disk comes at a cost, so not every tiny piece of
+  information should be actually cached in between compilation sessions.
+  Fixed-sized, plain-old-data is preferred to complex things that need to run
+  through an expensive (de-)serialization step.
+
+The following sections describe how the compiler solves these issues.
+
+### A Question Of Stability: Bridging The Gap Between Compilation Sessions
+
+As noted before, various IDs (like `DefId`) are generated by the compiler in a
+way that depends on the contents of the source code being compiled. ID assignment
+is usually deterministic, that is, if the exact same code is compiled twice,
+the same things will end up with the same IDs. However, if something
+changes, e.g. a function is added in the middle of a file, there is no
+guarantee that anything will have the same ID as it had before.
+
+As a consequence we cannot represent the data in our on-disk cache the same
+way it is represented in memory. For example, if we just stored a piece
+of type information like `TyKind::FnDef(DefId, &'tcx Substs<'tcx>)` (as we do
+in memory) and then the contained `DefId` points to a different function in
+a new compilation session we'd be in trouble.
+
+The solution to this problem is to find "stable" forms for IDs which remain
+valid in between compilation sessions. For the most important case, `DefId`s,
+these are the so-called `DefPath`s. Each `DefId` has a
+corresponding `DefPath` but in place of a numeric ID, a `DefPath` is based on
+the path to the identified item, e.g. `std::collections::HashMap`. The
+advantage of an ID like this is that it is not affected by unrelated changes.
+For example, one can add a new function to `std::collections` but
+`std::collections::HashMap` would still be `std::collections::HashMap`. A
+`DefPath` is "stable" across changes made to the source code while a `DefId`
+isn't.
+
+There is also the `DefPathHash` which is just a 128-bit hash value of the
+`DefPath`. The two contain the same information and we mostly use the
+`DefPathHash` because it simpler to handle, being `Copy` and self-contained.
+
+This principle of stable identifiers is used to make the data in the on-disk
+cache resilient to source code changes. Instead of storing a `DefId`, we store
+the `DefPathHash` and when we deserialize something from the cache, we map the
+`DefPathHash` to the corresponding `DefId` in the *current* compilation session
+(which is just a simple hash table lookup).
+
+The `HirId`, used for identifying HIR components that don't have their own
+`DefId`, is another such stable ID. It is (conceptually) a pair of a `DefPath`
+and a `LocalId`, where the `LocalId` identifies something (e.g. a `hir::Expr`)
+locally within its "owner" (e.g. a `hir::Item`). If the owner is moved around,
+the `LocalId`s within it are still the same.
+
+
+
+### Checking Query Results For Changes: HashStable And Fingerprints
+
+In order to do red-green-marking we often need to check if the result of a
+query has changed compared to the result it had during the previous
+compilation session. There are two performance problems with this though:
+
+- We'd like to avoid having to load the previous result from disk just for
+  doing the comparison. We already computed the new result and will use that.
+  Also loading a result from disk will "pollute" the interners with data that
+  is unlikely to ever be used.
+- We don't want to store each and every result in the on-disk cache. For
+  example, it would be wasted effort to persist things to disk that are
+  already available in upstream crates.
+
+The compiler avoids these problems by using so-called `Fingerprint`s. Each time
+a new query result is computed, the query engine will compute a 128 bit hash
+value of the result. We call this hash value "the `Fingerprint` of the query
+result". The hashing is (and has to be) done "in a stable way". This means
+that whenever something is hashed that might change in between compilation
+sessions (e.g. a `DefId`), we instead hash its stable equivalent
+(e.g. the corresponding `DefPath`). That's what the whole `HashStable`
+infrastructure is for. This way `Fingerprint`s computed in two
+different compilation sessions are still comparable.
+
+The next step is to store these fingerprints along with the dependency graph.
+This is cheap since fingerprints are just bytes to be copied. It's also cheap to
+load the entire set of fingerprints together with the dependency graph.
+
+Now, when red-green-marking reaches the point where it needs to check if a
+result has changed, it can just compare the (already loaded) previous
+fingerprint to the fingerprint of the new result.
+
+This approach works rather well but it's not without flaws:
+
+- There is a small possibility of hash collisions. That is, two different
+  results could have the same fingerprint and the system would erroneously
+  assume that the result hasn't changed, leading to a missed update.
+
+  We mitigate this risk by using a high-quality hash function and a 128 bit
+  wide hash value. Due to these measures the practical risk of a hash
+  collision is negligible.
+
+- Computing fingerprints is quite costly. It is the main reason why incremental
+  compilation can be slower than non-incremental compilation. We are forced to
+  use a good and thus expensive hash function, and we have to map things to
+  their stable equivalents while doing the hashing.
+
+
+### A Tale Of Two DepGraphs: The Old And The New
+
+The initial description of dependency tracking glosses over a few details
+that quickly become a head scratcher when actually trying to implement things.
+In particular it's easy to overlook that we are actually dealing with *two*
+dependency graphs: The one we built during the previous compilation session and
+the one that we are building for the current compilation session.
+
+When a compilation session starts, the compiler loads the previous dependency
+graph into memory as an immutable piece of data. Then, when a query is invoked,
+it will first try to mark the corresponding node in the graph as green. This
+means really that we are trying to mark the node in the *previous* dep-graph
+as green that corresponds to the query key in the *current* session. How do we
+do this mapping between current query key and previous `DepNode`? The answer
+is again `Fingerprint`s: Nodes in the dependency graph are identified by a
+fingerprint of the query key. Since fingerprints are stable across compilation
+sessions, computing one in the current session allows us to find a node
+in the dependency graph from the previous session. If we don't find a node with
+the given fingerprint, it means that the query key refers to something that
+did not yet exist in the previous session.
+
+So, having found the dep-node in the previous dependency graph, we can look
+up its dependencies (i.e. also dep-nodes in the previous graph) and continue with
+the rest of the try-mark-green algorithm. The next interesting thing happens
+when we successfully marked the node as green. At that point we copy the node
+and the edges to its dependencies from the old graph into the new graph. We
+have to do this because the new dep-graph cannot acquire the
+node and edges via the regular dependency tracking. The tracking system can
+only record edges while actually running a query -- but running the query,
+although we have the result already cached, is exactly what we want to avoid.
+
+Once the compilation session has finished, all the unchanged parts have been
+copied over from the old into the new dependency graph, while the changed parts
+have been added to the new graph by the tracking system. At this point, the
+new graph is serialized out to disk, alongside the query result cache, and can
+act as the previous dep-graph in a subsequent compilation session.
+
+
+### Didn't You Forget Something?: Cache Promotion
+
+The system described so far has a somewhat subtle property: If all inputs of a
+dep-node are green then the dep-node itself can be marked as green without
+computing or loading the corresponding query result. Applying this property
+transitively often leads to the situation that some intermediate results are
+never actually loaded from disk, as in the following example:
+
+```ignore
+   input(A) <-- intermediate_query(B) <-- leaf_query(C)
+```
+
+The compiler might need the value of `leaf_query(C)` in order to generate some
+output artifact. If it can mark `leaf_query(C)` as green, it will load the
+result from the on-disk cache. The result of `intermediate_query(B)` is never
+loaded though. As a consequence, when the compiler persists the *new* result
+cache by writing all in-memory query results to disk, `intermediate_query(B)`
+will not be in memory and thus will be missing from the new result cache.
+
+If there subsequently is another compilation session that actually needs the
+result of `intermediate_query(B)` it will have to be re-computed even though we
+had a perfectly valid result for it in the cache just before.
+
+In order to prevent this from happening, the compiler does something called
+"cache promotion": Before emitting the new result cache it will walk all green
+dep-nodes and make sure that their query result is loaded into memory. That way
+the result cache doesn't unnecessarily shrink again.
+
+
+
+# Incremental Compilation and the Compiler Backend
+
+The compiler backend, the part involving LLVM, is using the query system but
+it is not implemented in terms of queries itself. As a consequence
+it does not automatically partake in dependency tracking. However, the manual
+integration with the tracking system is pretty straight-forward. The compiler
+simply tracks what queries get invoked when generating the initial LLVM version
+of each codegen unit, which results in a dep-node for each of them. In
+subsequent compilation sessions it then tries to mark the dep-node for a CGU as
+green. If it succeeds it knows that the corresponding object and bitcode files
+on disk are still valid. If it doesn't succeed, the entire codegen unit has to
+be recompiled.
+
+This is the same approach that is used for regular queries. The main differences
+are:
+
+ - that we cannot easily compute a fingerprint for LLVM modules (because
+   they are opaque C++ objects),
+
+ - that the logic for dealing with cached values is rather different from
+   regular queries because here we have bitcode and object files instead of
+   serialized Rust values in the common result cache file, and
+
+ - the operations around LLVM are so expensive in terms of computation time and
+   memory consumption that we need to have tight control over what is
+   executed when and what stays in memory for how long.
+
+The query system could probably be extended with general purpose mechanisms to
+deal with all of the above but so far that seemed like more trouble than it
+would save.
+
+
+
+## Query Modifiers
+
+The query system allows for applying [modifiers][mod] to queries. These
+modifiers affect certain aspects of how the system treats the query with
+respect to incremental compilation:
+
+ - `eval_always` - A query with the `eval_always` attribute is re-executed
+   unconditionally during incremental compilation. I.e. the system will not
+   even try to mark the query's dep-node as green. This attribute has two use
+   cases:
+
+    - `eval_always` queries can read inputs (from files, global state, etc).
+      They can also produce side effects like writing to files and changing global state.
+
+    - Some queries are very likely to be re-evaluated because their result
+      depends on the entire source code. In this case `eval_always` can be used
+      as an optimization because the system can skip recording dependencies in
+      the first place.
+
+ - `no_hash` - Applying `no_hash` to a query tells the system to not compute
+   the fingerprint of the query's result. This has two consequences:
+
+    - Not computing the fingerprint can save quite a bit of time because
+      fingerprinting is expensive, especially for large, complex values.
+
+    - Without the fingerprint, the system has to unconditionally assume that
+      the result of the query has changed. As a consequence anything depending
+      on a `no_hash` query will always be re-executed.
+
+   Using `no_hash` for a query can make sense in two circumstances:
+
+    - If the result of the query is very likely to change whenever one of its
+      inputs changes, e.g. a function like `|a, b, c| -> (a * b * c)`. In such
+      a case recomputing the query will always yield a red node if one of the
+      inputs is red so we can spare us the trouble and default to red immediately.
+      A counter example would be a function like `|a| -> (a == 42)` where the
+      result does not change for most changes of `a`.
+
+    - If the result of a query is a big, monolithic collection (e.g. `index_hir`)
+      and there are "projection queries" reading from that collection
+      (e.g. `hir_owner`). In such a case the big collection will likely fulfill the
+      condition above (any changed input means recomputing the whole collection)
+      and the results of the projection queries will be hashed anyway. If we also
+      hashed the collection query it would mean that we effectively hash the same
+      data twice: once when hashing the collection and another time when hashing all
+      the projection query results. `no_hash` allows us to avoid that redundancy
+      and the projection queries act as a "firewall", shielding their dependents
+      from the unconditionally red `no_hash` node.
+
+ - `cache_on_disk_if` - This attribute is what determines which query results
+   are persisted in the incremental compilation query result cache. The
+   attribute takes an expression that allows per query invocation
+   decisions. For example, it makes no sense to store values from upstream
+   crates in the cache because they are already available in the upstream
+   crate's metadata.
+
+ - `anon` - This attribute makes the system use "anonymous" dep-nodes for the
+   given query. An anonymous dep-node is not identified by the corresponding
+   query key, instead its ID is computed from the IDs of its dependencies. This
+   allows the red-green system to do its change detection even if there is no
+   query key available for a given dep-node -- something which is needed for
+   handling trait selection because it is not based on queries.
+
+[mod]: ../query.html#adding-a-new-kind-of-query
+
+
+## The Projection Query Pattern
+
+It's interesting to note that `eval_always` and `no_hash` can be used together
+in the so-called "projection query" pattern. It is often the case that there is
+one query that depends on the entirety of the compiler's input (e.g. the indexed HIR)
+and another query that projects individual values out of this monolithic value
+(e.g. a HIR item with a certain `DefId`). These projection queries allow for
+building change propagation "firewalls" because even if the result of the
+monolithic query changes (which it is very likely to do) the small projections
+can still mostly be marked as green.
+
+
+```ignore
+  +------------+
+  |            |           +---------------+           +--------+
+  |            | <---------| projection(x) | <---------| foo(a) |
+  |            |           +---------------+           +--------+
+  |            |
+  | monolithic |           +---------------+           +--------+
+  |   query    | <---------| projection(y) | <---------| bar(b) |
+  |            |           +---------------+           +--------+
+  |            |
+  |            |           +---------------+           +--------+
+  |            | <---------| projection(z) | <---------| baz(c) |
+  |            |           +---------------+           +--------+
+  +------------+
+```
+
+Let's assume that the result `monolithic_query` changes so that also the result
+of `projection(x)` has changed, i.e. both their dep-nodes are being marked as
+red. As a consequence `foo(a)` needs to be re-executed; but `bar(b)` and
+`baz(c)` can be marked as green. However, if `foo`, `bar`, and `baz` would have
+directly depended on `monolithic_query` then all of them would have had to be
+re-evaluated.
+
+This pattern works even without `eval_always` and `no_hash` but the two
+modifiers can be used to avoid unnecessary overhead. If the monolithic query
+is likely to change at any minor modification of the compiler's input it makes
+sense to mark it as `eval_always`, thus getting rid of its dependency tracking
+cost. And it always makes sense to mark the monolithic query as `no_hash`
+because we have the projections to take care of keeping things green as much
+as possible.
+
+
+# Shortcomings of the Current System
+
+There are many things that still can be improved.
+
+## Incrementality of on-disk data structures
+
+The current system is not able to update on-disk caches and the dependency graph
+in-place. Instead it has to rewrite each file entirely in each compilation
+session. The overhead of doing so is a few percent of total compilation time.
+
+## Unnecessary data dependencies
+
+Data structures used as query results could be factored in a way that removes
+edges from the dependency graph. Especially "span" information is very volatile,
+so including it in query result will increase the chance that that result won't
+be reusable. See <https://github.com/rust-lang/rust/issues/47389> for more
+information.
+
+
+
+[query-model]: ./query-evaluation-model-in-detail.html
diff --git a/src/doc/rustc-dev-guide/src/queries/incremental-compilation.md b/src/doc/rustc-dev-guide/src/queries/incremental-compilation.md
new file mode 100644
index 000000000..abef144d7
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/incremental-compilation.md
@@ -0,0 +1,151 @@
+# Incremental compilation
+
+<!-- toc -->
+
+The incremental compilation scheme is, in essence, a surprisingly
+simple extension to the overall query system. We'll start by describing
+a slightly simplified variant of the real thing – the "basic algorithm" –
+and then describe some possible improvements.
+
+## The basic algorithm
+
+The basic algorithm is
+called the **red-green** algorithm[^salsa]. The high-level idea is
+that, after each run of the compiler, we will save the results of all
+the queries that we do, as well as the **query DAG**. The
+**query DAG** is a [DAG] that indexes which queries executed which
+other queries. So, for example, there would be an [edge] from a query Q1
+to another query Q2 if computing Q1 required computing Q2 (note that
+because queries cannot depend on themselves, this results in a DAG and
+not a general graph).
+
+[DAG]: https://en.wikipedia.org/wiki/Directed_acyclic_graph
+
+On the next run of the compiler, then, we can sometimes reuse these
+query results to avoid re-executing a query. We do this by assigning
+every query a **color**:
+
+- If a query is colored **red**, that means that its result during
+  this compilation has **changed** from the previous compilation.
+- If a query is colored **green**, that means that its result is
+  the **same** as the previous compilation.
+
+There are two key insights here:
+
+- First, if all the inputs to query Q are colored green, then the
+  query Q **must** result in the same value as last time and hence
+  need not be re-executed (or else the compiler is not deterministic).
+- Second, even if some inputs to a query changes, it may be that it
+  **still** produces the same result as the previous compilation. In
+  particular, the query may only use part of its input.
+  - Therefore, after executing a query, we always check whether it
+    produced the same result as the previous time. **If it did,** we
+    can still mark the query as green, and hence avoid re-executing
+    dependent queries.
+
+### The try-mark-green algorithm
+
+At the core of incremental compilation is an algorithm called
+"try-mark-green". It has the job of determining the color of a given
+query Q (which must not have yet been executed). In cases where Q has
+red inputs, determining Q's color may involve re-executing Q so that
+we can compare its output, but if all of Q's inputs are green, then we
+can conclude that Q must be green without re-executing it or inspecting
+its value at all. In the compiler, this allows us to avoid
+deserializing the result from disk when we don't need it, and in fact
+enables us to sometimes skip *serializing* the result as well
+(see the refinements section below).
+
+Try-mark-green works as follows:
+
+- First check if the query Q was executed during the previous compilation.
+  - If not, we can just re-execute the query as normal, and assign it the
+    color of red.
+- If yes, then load the 'dependent queries' of Q.
+- If there is a saved result, then we load the `reads(Q)` vector from the
+  query DAG. The "reads" is the set of queries that Q executed during
+  its execution.
+  - For each query R in `reads(Q)`, we recursively demand the color
+    of R using try-mark-green.
+    - Note: it is important that we visit each node in `reads(Q)` in same order
+      as they occurred in the original compilation. See [the section on the
+      query DAG below](#dag).
+    - If **any** of the nodes in `reads(Q)` wind up colored **red**, then Q is
+      dirty.
+      - We re-execute Q and compare the hash of its result to the hash of the
+        result from the previous compilation.
+      - If the hash has not changed, we can mark Q as **green** and return.
+    - Otherwise, **all** of the nodes in `reads(Q)` must be **green**. In that
+      case, we can color Q as **green** and return.
+
+<a name="dag"></a>
+
+### The query DAG
+
+The query DAG code is stored in
+[`compiler/rustc_middle/src/dep_graph`][dep_graph]. Construction of the DAG is done
+by instrumenting the query execution.
+
+One key point is that the query DAG also tracks ordering; that is, for
+each query Q, we not only track the queries that Q reads, we track the
+**order** in which they were read.  This allows try-mark-green to walk
+those queries back in the same order. This is important because once a
+subquery comes back as red, we can no longer be sure that Q will continue
+along the same path as before. That is, imagine a query like this:
+
+```rust,ignore
+fn main_query(tcx) {
+    if tcx.subquery1() {
+        tcx.subquery2()
+    } else {
+        tcx.subquery3()
+    }
+}
+```
+
+Now imagine that in the first compilation, `main_query` starts by
+executing `subquery1`, and this returns true. In that case, the next
+query `main_query` executes will be `subquery2`, and `subquery3` will
+not be executed at all.
+
+But now imagine that in the **next** compilation, the input has
+changed such that `subquery1` returns **false**. In this case, `subquery2`
+would never execute. If try-mark-green were to visit `reads(main_query)` out
+of order, however, it might visit `subquery2` before `subquery1`, and hence
+execute it.
+This can lead to ICEs and other problems in the compiler.
+
+[dep_graph]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/dep_graph/index.html
+
+## Improvements to the basic algorithm
+
+In the description of the basic algorithm, we said that at the end of
+compilation we would save the results of all the queries that were
+performed.  In practice, this can be quite wasteful – many of those
+results are very cheap to recompute, and serializing and deserializing
+them is not a particular win. In practice, what we would do is to save
+**the hashes** of all the subqueries that we performed. Then, in select cases,
+we **also** save the results.
+
+This is why the incremental algorithm separates computing the
+**color** of a node, which often does not require its value, from
+computing the **result** of a node. Computing the result is done via a simple
+algorithm like so:
+
+- Check if a saved result for Q is available. If so, compute the color of Q.
+  If Q is green, deserialize and return the saved result.
+- Otherwise, execute Q.
+  - We can then compare the hash of the result and color Q as green if
+    it did not change.
+
+## Resources
+The initial design document can be found [here][initial-design], which expands
+on the memoization details, provides more high-level overview and motivation
+for this system.
+
+# Footnotes
+
+[^salsa]: I have long wanted to rename it to the Salsa algorithm, but it never caught on. -@nikomatsakis
+
+[edge]: https://en.wikipedia.org/wiki/Glossary_of_graph_theory_terms#edge
+[initial-design]: https://github.com/nikomatsakis/rustc-on-demand-incremental-design-doc/blob/master/0000-rustc-on-demand-and-incremental.md
diff --git a/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
new file mode 100644
index 000000000..b84a5dac4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
@@ -0,0 +1,213 @@
+# The Query Evaluation Model in Detail
+
+<!-- toc -->
+
+This chapter provides a deeper dive into the abstract model queries are built on.
+It does not go into implementation details but tries to explain
+the underlying logic. The examples here, therefore, have been stripped down and
+simplified and don't directly reflect the compilers internal APIs.
+
+## What is a query?
+
+Abstractly we view the compiler's knowledge about a given crate as a "database"
+and queries are the way of asking the compiler questions about it, i.e.
+we "query" the compiler's "database" for facts.
+
+However, there's something special to this compiler database: It starts out empty
+and is filled on-demand when queries are executed. Consequently, a query must
+know how to compute its result if the database does not contain it yet. For
+doing so, it can access other queries and certain input values that the database
+is pre-filled with on creation.
+
+A query thus consists of the following things:
+
+ - A name that identifies the query
+ - A "key" that specifies what we want to look up
+ - A result type that specifies what kind of result it yields
+ - A "provider" which is a function that specifies how the result is to be
+   computed if it isn't already present in the database.
+
+As an example, the name of the `type_of` query is `type_of`, its query key is a
+`DefId` identifying the item we want to know the type of, the result type is
+`Ty<'tcx>`, and the provider is a function that, given the query key and access
+to the rest of the database, can compute the type of the item identified by the
+key.
+
+So in some sense a query is just a function that maps the query key to the
+corresponding result. However, we have to apply some restrictions in order for
+this to be sound:
+
+ - The key and result must be immutable values.
+ - The provider function must be a pure function in the sense that for the same
+   key it must always yield the same result.
+ - The only parameters a provider function takes are the key and a reference to
+   the "query context" (which provides access to the rest of the "database").
+
+The database is built up lazily by invoking queries. The query providers will
+invoke other queries, for which the result is either already cached or computed
+by calling another query provider. These query provider invocations
+conceptually form a directed acyclic graph (DAG) at the leaves of which are
+input values that are already known when the query context is created.
+
+
+
+## Caching/Memoization
+
+Results of query invocations are "memoized" which means that the query context
+will cache the result in an internal table and, when the query is invoked with
+the same query key again, will return the result from the cache instead of
+running the provider again.
+
+This caching is crucial for making the query engine efficient. Without
+memoization the system would still be sound (that is, it would yield the same
+results) but the same computations would be done over and over again.
+
+Memoization is one of the main reasons why query providers have to be pure
+functions. If calling a provider function could yield different results for
+each invocation (because it accesses some global mutable state) then we could
+not memoize the result.
+
+
+
+## Input data
+
+When the query context is created, it is still empty: No queries have been
+executed, no results are cached. But the context already provides access to
+"input" data, i.e. pieces of immutable data that were computed before the
+context was created and that queries can access to do their computations.
+
+As of <!-- date: 2021-01 --> January 2021, this input data consists mainly of
+the HIR map, upstream crate metadata, and the command-line options the compiler
+was invoked with; but in the future inputs will just consist of command-line
+options and a list of source files -- the HIR map will itself be provided by a
+query which processes these source files.
+
+Without inputs, queries would live in a void without anything to compute their
+result from (remember, query providers only have access to other queries and
+the context but not any other outside state or information).
+
+For a query provider, input data and results of other queries look exactly the
+same: It just tells the context "give me the value of X". Because input data
+is immutable, the provider can rely on it being the same across
+different query invocations, just as is the case for query results.
+
+
+
+## An example execution trace of some queries
+
+How does this DAG of query invocations come into existence? At some point
+the compiler driver will create the, as yet empty, query context. It will then,
+from outside of the query system, invoke the queries it needs to perform its
+task. This looks something like the following:
+
+```rust,ignore
+fn compile_crate() {
+    let cli_options = ...;
+    let hir_map = ...;
+
+    // Create the query context `tcx`
+    let tcx = TyCtxt::new(cli_options, hir_map);
+
+    // Do type checking by invoking the type check query
+    tcx.type_check_crate();
+}
+```
+
+The `type_check_crate` query provider would look something like the following:
+
+```rust,ignore
+fn type_check_crate_provider(tcx, _key: ()) {
+    let list_of_hir_items = tcx.hir_map.list_of_items();
+
+    for item_def_id in list_of_hir_items {
+        tcx.type_check_item(item_def_id);
+    }
+}
+```
+
+We see that the `type_check_crate` query accesses input data
+(`tcx.hir_map.list_of_items()`) and invokes other queries
+(`type_check_item`). The `type_check_item`
+invocations will themselves access input data and/or invoke other queries,
+so that in the end the DAG of query invocations will be built up backwards
+from the node that was initially executed:
+
+```ignore
+         (2)                                                 (1)
+  list_of_all_hir_items <----------------------------- type_check_crate()
+                                                               |
+    (5)             (4)                  (3)                   |
+  Hir(foo) <--- type_of(foo) <--- type_check_item(foo) <-------+
+                                      |                        |
+                    +-----------------+                        |
+                    |                                          |
+    (7)             v  (6)                  (8)                |
+  Hir(bar) <--- type_of(bar) <--- type_check_item(bar) <-------+
+
+// (x) denotes invocation order
+```
+
+We also see that often a query result can be read from the cache:
+`type_of(bar)` was computed for `type_check_item(foo)` so when
+`type_check_item(bar)` needs it, it is already in the cache.
+
+Query results stay cached in the query context as long as the context lives.
+So if the compiler driver invoked another query later on, the above graph
+would still exist and already executed queries would not have to be re-done.
+
+
+
+## Cycles
+
+Earlier we stated that query invocations form a DAG. However, it would be easy
+to form a cyclic graph by, for example, having a query provider like the
+following:
+
+```rust,ignore
+fn cyclic_query_provider(tcx, key) -> u32 {
+  // Invoke the same query with the same key again
+  tcx.cyclic_query(key)
+}
+```
+
+Since query providers are regular functions, this would behave much as expected:
+Evaluation would get stuck in an infinite recursion. A query like this would not
+be very useful either. However, sometimes certain kinds of invalid user input
+can result in queries being called in a cyclic way. The query engine includes
+a check for cyclic invocations and, because cycles are an irrecoverable error,
+will abort execution with a "cycle error" messages that tries to be human
+readable.
+
+At some point the compiler had a notion of "cycle recovery", that is, one could
+"try" to execute a query and if it ended up causing a cycle, proceed in some
+other fashion. However, this was later removed because it is not entirely
+clear what the theoretical consequences of this are, especially regarding
+incremental compilation.
+
+
+## "Steal" Queries
+
+Some queries have their result wrapped in a `Steal<T>` struct. These queries
+behave exactly the same as regular with one exception: Their result is expected
+to be "stolen" out of the cache at some point, meaning some other part of the
+program is taking ownership of it and the result cannot be accessed anymore.
+
+This stealing mechanism exists purely as a performance optimization because some
+result values are too costly to clone (e.g. the MIR of a function). It seems
+like result stealing would violate the condition that query results must be
+immutable (after all we are moving the result value out of the cache) but it is
+OK as long as the mutation is not observable. This is achieved by two things:
+
+- Before a result is stolen, we make sure to eagerly run all queries that
+  might ever need to read that result. This has to be done manually by calling
+  those queries.
+- Whenever a query tries to access a stolen result, we make the compiler ICE so
+  that such a condition cannot go unnoticed.
+
+This is not an ideal setup because of the manual intervention needed, so it
+should be used sparingly and only when it is well known which queries might
+access a given result. In practice, however, stealing has not turned out to be
+much of a maintenance burden.
+
+To summarize: "Steal queries" break some of the rules in a controlled way.
+There are checks in place that make sure that nothing can go silently wrong.
diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
new file mode 100644
index 000000000..95e570dfc
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/query.md
@@ -0,0 +1,315 @@
+# Queries: demand-driven compilation
+
+<!-- toc -->
+
+As described in [the high-level overview of the compiler][hl], the Rust compiler
+is still (as of <!-- date: 2021-07 --> July 2021) transitioning from a
+traditional "pass-based" setup to a "demand-driven" system. The compiler query
+system is the key to rustc's demand-driven organization.
+The idea is pretty simple. Instead of entirely independent passes
+(parsing, type-checking, etc.), a set of function-like *queries*
+compute information about the input source. For example,
+there is a query called `type_of` that, given the [`DefId`] of
+some item, will compute the type of that item and return it to you.
+
+[`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/def_id/struct.DefId.html
+[hl]: ./compiler-src.md
+
+Query execution is *memoized*. The first time you invoke a
+query, it will go do the computation, but the next time, the result is
+returned from a hashtable. Moreover, query execution fits nicely into
+*incremental computation*; the idea is roughly that, when you invoke a
+query, the result *may* be returned to you by loading stored data
+from disk.[^incr-comp-detail]
+
+Eventually, we want the entire compiler
+control-flow to be query driven. There will effectively be one
+top-level query (`compile`) that will run compilation on a crate; this
+will in turn demand information about that crate, starting from the
+*end*.  For example:
+
+- The `compile` query might demand to get a list of codegen-units
+  (i.e. modules that need to be compiled by LLVM).
+- But computing the list of codegen-units would invoke some subquery
+  that returns the list of all modules defined in the Rust source.
+- That query in turn would invoke something asking for the HIR.
+- This keeps going further and further back until we wind up doing the
+  actual parsing.
+
+Although this vision is not fully realized, large sections of the
+compiler (for example, generating [MIR](./mir/index.md)) currently work exactly like this.
+
+[^incr-comp-detail]: The ["Incremental Compilation in Detail](queries/incremental-compilation-in-detail.md) chapter gives a more
+in-depth description of what queries are and how they work.
+If you intend to write a query of your own, this is a good read.
+
+## Invoking queries
+
+Invoking a query is simple. The [`TyCtxt`] ("type context") struct offers a method
+for each defined query. For example, to invoke the `type_of`
+query, you would just do this:
+
+```rust,ignore
+let ty = tcx.type_of(some_def_id);
+```
+
+[`TyCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html
+
+## How the compiler executes a query
+
+So you may be wondering what happens when you invoke a query
+method. The answer is that, for each query, the compiler maintains a
+cache – if your query has already been executed, then, the answer is
+simple: we clone the return value out of the cache and return it
+(therefore, you should try to ensure that the return types of queries
+are cheaply cloneable; insert an `Rc` if necessary).
+
+### Providers
+
+If, however, the query is *not* in the cache, then the compiler will
+try to find a suitable **provider**. A provider is a function that has
+been defined and linked into the compiler somewhere that contains the
+code to compute the result of the query.
+
+**Providers are defined per-crate.** The compiler maintains,
+internally, a table of providers for every crate, at least
+conceptually. Right now, there are really two sets: the providers for
+queries about the **local crate** (that is, the one being compiled)
+and providers for queries about **external crates** (that is,
+dependencies of the local crate). Note that what determines the crate
+that a query is targeting is not the *kind* of query, but the *key*.
+For example, when you invoke `tcx.type_of(def_id)`, that could be a
+local query or an external query, depending on what crate the `def_id`
+is referring to (see the [`self::keys::Key`][Key] trait for more
+information on how that works).
+
+Providers always have the same signature:
+
+```rust,ignore
+fn provider<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    key: QUERY_KEY,
+) -> QUERY_RESULT {
+    ...
+}
+```
+
+Providers take two arguments: the `tcx` and the query key.
+They return the result of the query.
+
+###  How providers are setup
+
+When the tcx is created, it is given the providers by its creator using
+the [`Providers`][providers_struct] struct. This struct is generated by
+the macros here, but it is basically a big list of function pointers:
+
+[providers_struct]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/query/struct.Providers.html
+
+```rust,ignore
+struct Providers {
+    type_of: for<'tcx> fn(TyCtxt<'tcx>, DefId) -> Ty<'tcx>,
+    ...
+}
+```
+
+At present, we have one copy of the struct for local crates, and one
+for external crates, though the plan is that we may eventually have
+one per crate.
+
+These `Providers` structs are ultimately created and populated by
+`rustc_driver`, but it does this by distributing the work
+throughout the other `rustc_*` crates. This is done by invoking
+various [`provide`][provide_fn] functions. These functions tend to look
+something like this:
+
+[provide_fn]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/fn.provide.html
+
+```rust,ignore
+pub fn provide(providers: &mut Providers) {
+    *providers = Providers {
+        type_of,
+        ..*providers
+    };
+}
+```
+
+That is, they take an `&mut Providers` and mutate it in place. Usually
+we use the formulation above just because it looks nice, but you could
+as well do `providers.type_of = type_of`, which would be equivalent.
+(Here, `type_of` would be a top-level function, defined as we saw
+before.) So, if we want to add a provider for some other query,
+let's call it `fubar`, into the crate above, we might modify the `provide()`
+function like so:
+
+```rust,ignore
+pub fn provide(providers: &mut Providers) {
+    *providers = Providers {
+        type_of,
+        fubar,
+        ..*providers
+    };
+}
+
+fn fubar<'tcx>(tcx: TyCtxt<'tcx>, key: DefId) -> Fubar<'tcx> { ... }
+```
+
+N.B. Most of the `rustc_*` crates only provide **local
+providers**. Almost all **extern providers** wind up going through the
+[`rustc_metadata` crate][rustc_metadata], which loads the information
+from the crate metadata. But in some cases there are crates that
+provide queries for *both* local and external crates, in which case
+they define both a `provide` and a `provide_extern` function, through
+[`wasm_import_module_map`][wasm_import_module_map], that `rustc_driver` can invoke.
+
+[rustc_metadata]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/index.html
+[wasm_import_module_map]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/back/symbol_export/fn.wasm_import_module_map.html
+
+## Adding a new query
+
+How do you add a new query?
+Defining a query takes place in two steps:
+
+1. Specify the query name and its arguments.
+2. Supply query providers where needed.
+
+To specify the query name and arguments, you simply add an entry to
+the big macro invocation in
+[`compiler/rustc_middle/src/query/mod.rs`][query-mod], which looks something like:
+
+[query-mod]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/query/index.html
+
+```rust,ignore
+rustc_queries! {
+    Other {
+        /// Records the type of every item.
+        query type_of(key: DefId) -> Ty<'tcx> {
+            cache { key.is_local() }
+        }
+    }
+
+    ...
+}
+```
+
+Queries are grouped into categories (`Other`, `Codegen`, `TypeChecking`, etc.).
+Each group contains one or more queries.
+
+A query definition has the following form:
+
+```rust,ignore
+query type_of(key: DefId) -> Ty<'tcx> { ... }
+^^^^^ ^^^^^^^      ^^^^^     ^^^^^^^^   ^^^
+|     |            |         |          |
+|     |            |         |          query modifiers
+|     |            |         result type
+|     |            query key type
+|     name of query
+query keyword
+```
+
+Let's go over these elements one by one:
+
+- **Query keyword:** indicates a start of a query definition.
+- **Name of query:** the name of the query method
+  (`tcx.type_of(..)`). Also used as the name of a struct
+  (`ty::queries::type_of`) that will be generated to represent
+  this query.
+- **Query key type:** the type of the argument to this query.
+  This type must implement the [`ty::query::keys::Key`][Key] trait, which
+  defines (for example) how to map it to a crate, and so forth.
+- **Result type of query:** the type produced by this query. This type
+  should (a) not use `RefCell` or other interior mutability and (b) be
+  cheaply cloneable. Interning or using `Rc` or `Arc` is recommended for
+  non-trivial data types.[^steal]
+- **Query modifiers:** various flags and options that customize how the
+  query is processed (mostly with respect to [incremental compilation][incrcomp]).
+
+[Key]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_query_impl/keys/trait.Key.html
+[incrcomp]: queries/incremental-compilation-in-detail.html#query-modifiers
+
+So, to add a query:
+
+- Add an entry to `rustc_queries!` using the format above.
+- Link the provider by modifying the appropriate `provide` method;
+  or add a new one if needed and ensure that `rustc_driver` is invoking it.
+
+[^steal]: The one exception to those rules is the `ty::steal::Steal` type,
+which is used to cheaply modify MIR in place. See the definition
+of `Steal` for more details. New uses of `Steal` should **not** be
+added without alerting `@rust-lang/compiler`.
+
+### Query structs and descriptions
+
+For each query, the `rustc_queries` macro will generate a "query struct"
+named after the query. This struct is a kind of placeholder
+describing the query. Each query struct implements the
+[`self::config::QueryConfig`][QueryConfig] trait, which has associated types for the
+key/value of that particular query. Basically the code generated looks something
+like this:
+
+```rust,ignore
+// Dummy struct representing a particular kind of query:
+pub struct type_of<'tcx> { data: PhantomData<&'tcx ()> }
+
+impl<'tcx> QueryConfig for type_of<'tcx> {
+  type Key = DefId;
+  type Value = Ty<'tcx>;
+
+  const NAME: QueryName = QueryName::type_of;
+  const CATEGORY: ProfileCategory = ProfileCategory::Other;
+}
+```
+
+There is an additional trait that you may wish to implement called
+[`self::config::QueryDescription`][QueryDescription]. This trait is
+used during cycle errors to give a "human readable" name for the query,
+so that we can summarize what was happening when the cycle occurred.
+Implementing this trait is optional if the query key is `DefId`, but
+if you *don't* implement it, you get a pretty generic error ("processing `foo`...").
+You can put new impls into the `config` module. They look something like this:
+
+[QueryConfig]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_query_system/query/config/trait.QueryConfig.html
+[QueryDescription]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_query_system/query/config/trait.QueryDescription.html
+
+```rust,ignore
+impl<'tcx> QueryDescription for queries::type_of<'tcx> {
+    fn describe(tcx: TyCtxt, key: DefId) -> String {
+        format!("computing the type of `{}`", tcx.def_path_str(key))
+    }
+}
+```
+
+Another option is to add `desc` modifier:
+
+```rust,ignore
+rustc_queries! {
+    Other {
+        /// Records the type of every item.
+        query type_of(key: DefId) -> Ty<'tcx> {
+            desc { |tcx| "computing the type of `{}`", tcx.def_path_str(key) }
+        }
+    }
+}
+```
+
+`rustc_queries` macro will generate an appropriate `impl` automatically.
+
+## External links
+
+Related design ideas, and tracking issues:
+
+- Design document: [On-demand Rustc incremental design doc]
+- Tracking Issue: ["Red/Green" dependency tracking in compiler]
+
+More discussion and issues:
+
+- [GitHub issue #42633]
+- [Incremental Compilation Beta]
+- [Incremental Compilation Announcement]
+
+[On-demand Rustc incremental design doc]: https://github.com/nikomatsakis/rustc-on-demand-incremental-design-doc/blob/master/0000-rustc-on-demand-and-incremental.md
+["Red/Green" dependency tracking in compiler]: https://github.com/rust-lang/rust/issues/42293
+[GitHub issue #42633]: https://github.com/rust-lang/rust/issues/42633
+[Incremental Compilation Beta]: https://internals.rust-lang.org/t/incremental-compilation-beta/4721
+[Incremental Compilation Announcement]: https://blog.rust-lang.org/2016/09/08/incremental.html
+
diff --git a/src/doc/rustc-dev-guide/src/rustbot.md b/src/doc/rustc-dev-guide/src/rustbot.md
new file mode 100644
index 000000000..5350f44ef
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustbot.md
@@ -0,0 +1,63 @@
+# Mastering @rustbot
+
+`@rustbot` (also known as `triagebot`) is a utility robot that is mostly used to
+allow any contributor to achieve certain tasks that would normally require GitHub
+membership to the `rust-lang` organization. Its most interesting features for
+contributors to `rustc` are issue claiming and relabeling.
+
+## Issue claiming
+
+`@rustbot` exposes a command that allows anyone to assign an issue to themselves.
+If you see an issue you want to work on, you can send the following message as a
+comment on the issue at hand:
+
+    @rustbot claim
+
+This will tell `@rustbot` to assign the issue to you if it has no assignee yet.
+Note that because of some GitHub restrictions, you may be assigned indirectly,
+i.e. `@rustbot` will assign itself as a placeholder and edit the top comment to
+reflect the fact that the issue is now assigned to you.
+
+If you want to unassign from an issue, `@rustbot` has a different command:
+
+    @rustbot release-assignment
+
+## Issue relabeling
+
+Changing labels for an issue or PR is also normally reserved for members of the
+organization. However, `@rustbot` allows you to relabel an issue yourself, only
+with a few restrictions. This is mostly useful in two cases:
+
+**Helping with issue triage**: Rust's issue tracker has more than 5,000 open
+issues at the time of this writing, so labels are the most powerful tool that we
+have to keep it as tidy as possible. You don't need to spend hours in the issue tracker
+to triage issues, but if you open an issue, you should feel free to label it if
+you are comfortable with doing it yourself.
+
+**Updating the status of a PR**: We use "status labels" to reflect the status of
+PRs. For example, if your PR has merge conflicts, it will automatically be assigned
+the `S-waiting-on-author`, and reviewers might not review it until you rebase your
+PR. Once you do rebase your branch, you should change the labels yourself to remove
+the `S-waiting-on-author` label and add back `S-waiting-on-review`. In this case,
+the `@rustbot` command will look like this:
+
+    @rustbot label -S-waiting-on-author +S-waiting-on-review
+
+The syntax for this command is pretty loose, so there are other variants of this
+command invocation. For more details, see [the wiki page about labeling][labeling].
+
+[labeling]: https://github.com/rust-lang/triagebot/wiki/Labeling
+
+## Other commands
+
+If you are interested in seeing what `@rustbot` is capable of, check out its [wiki],
+which is meant as a reference for the bot and should be kept up to date every time the
+bot gets an upgrade.
+
+`@rustbot` is maintained by the Release team. If you have any feedback regarding
+existing commands or suggestions for new commands, feel free to reach out
+[on Zulip][zulip] or file an issue in [the triagebot repository][repo]
+
+[wiki]: https://github.com/rust-lang/triagebot/wiki
+[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/224082-t-release.2Ftriagebot
+[repo]: https://github.com/rust-lang/triagebot/
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver-getting-diagnostics.md b/src/doc/rustc-dev-guide/src/rustc-driver-getting-diagnostics.md
new file mode 100644
index 000000000..327415e5a
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustc-driver-getting-diagnostics.md
@@ -0,0 +1,44 @@
+# Example: Getting diagnostic through `rustc_interface`
+
+`rustc_interface` allows you to intercept diagnostics that would otherwise be printed to stderr.
+
+## Getting diagnostics
+
+To get diagnostics from the compiler,
+configure `rustc_interface::Config` to output diagnostic to a buffer,
+and run `TyCtxt.analysis`. The following was tested
+with <!-- date: 2022-06 --> `nightly-2022-06-05` (See [here][example]
+for the complete example):
+
+[example]: https://github.com/rust-lang/rustc-dev-guide/blob/master/examples/rustc-driver-getting-diagnostics.rs
+
+```rust
+let buffer = sync::Arc::new(sync::Mutex::new(Vec::new()));
+let config = rustc_interface::Config {
+    opts: config::Options {
+        // Configure the compiler to emit diagnostics in compact JSON format.
+        error_format: config::ErrorOutputType::Json {
+            pretty: false,
+            json_rendered: rustc_errors::emitter::HumanReadableErrorType::Default(
+                rustc_errors::emitter::ColorConfig::Never,
+            ),
+        },
+        /* other config */
+    },
+    // Redirect the diagnostic output of the compiler to a buffer.
+    diagnostic_output: rustc_session::DiagnosticOutput::Raw(Box::from(DiagnosticSink(
+        buffer.clone(),
+    ))),
+    /* other config */
+};
+rustc_interface::run_compiler(config, |compiler| {
+    compiler.enter(|queries| {
+        queries.global_ctxt().unwrap().take().enter(|tcx| {
+            // Run the analysis phase on the local crate to trigger the type error.
+            let _ = tcx.analysis(());
+        });
+    });
+});
+// Read buffered diagnostics.
+let diagnostics = String::from_utf8(buffer.lock().unwrap().clone()).unwrap();
+```
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver-interacting-with-the-ast.md b/src/doc/rustc-dev-guide/src/rustc-driver-interacting-with-the-ast.md
new file mode 100644
index 000000000..d70264fe4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustc-driver-interacting-with-the-ast.md
@@ -0,0 +1,49 @@
+# Example: Type checking through `rustc_interface`
+
+`rustc_interface` allows you to interact with Rust code at various stages of compilation.
+
+## Getting the type of an expression
+
+To get the type of an expression, use the `global_ctxt` to get a `TyCtxt`.
+The following was tested with <!-- date: 2022-06 --> `nightly-2022-06-05`
+(see [here][example] for the complete example):
+
+[example]: https://github.com/rust-lang/rustc-dev-guide/blob/master/examples/rustc-driver-interacting-with-the-ast.rs
+
+```rust
+let config = rustc_interface::Config {
+    input: config::Input::Str {
+        name: source_map::FileName::Custom("main.rs".to_string()),
+        input: "fn main() { let message = \"Hello, world!\"; println!(\"{}\", message); }"
+            .to_string(),
+    },
+    /* other config */
+};
+rustc_interface::run_compiler(config, |compiler| {
+    compiler.enter(|queries| {
+        // Analyze the crate and inspect the types under the cursor.
+        queries.global_ctxt().unwrap().take().enter(|tcx| {
+            // Every compilation contains a single crate.
+            let hir_krate = tcx.hir();
+            // Iterate over the top-level items in the crate, looking for the main function.
+            for id in hir_krate.items() {
+                let item = hir_krate.item(id);
+                // Use pattern-matching to find a specific node inside the main function.
+                if let rustc_hir::ItemKind::Fn(_, _, body_id) = item.kind {
+                    let expr = &tcx.hir().body(body_id).value;
+                    if let rustc_hir::ExprKind::Block(block, _) = expr.kind {
+                        if let rustc_hir::StmtKind::Local(local) = block.stmts[0].kind {
+                            if let Some(expr) = local.init {
+                                let hir_id = expr.hir_id; // hir_id identifies the string "Hello, world!"
+                                let def_id = tcx.hir().local_def_id(item.hir_id()); // def_id identifies the main function
+                                let ty = tcx.typeck(def_id).node_type(hir_id);
+                                println!("{:?}: {:?}", expr, ty);
+                            }
+                        }
+                    }
+                }
+            }
+        })
+    });
+});
+```
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver.md b/src/doc/rustc-dev-guide/src/rustc-driver.md
new file mode 100644
index 000000000..7250c852c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustc-driver.md
@@ -0,0 +1,45 @@
+# The Rustc Driver and Interface
+
+The [`rustc_driver`] is essentially `rustc`'s `main()` function. It acts as
+the glue for running the various phases of the compiler in the correct order,
+using the interface defined in the [`rustc_interface`] crate.
+
+The `rustc_interface` crate provides external users with an (unstable) API
+for running code at particular times during the compilation process, allowing
+third parties to effectively use `rustc`'s internals as a library for
+analyzing a crate or emulating the compiler in-process (e.g. the RLS or rustdoc).
+
+For those using `rustc` as a library, the [`rustc_interface::run_compiler()`][i_rc]
+function is the main entrypoint to the compiler. It takes a configuration for the compiler
+and a closure that takes a [`Compiler`]. `run_compiler` creates a `Compiler` from the
+configuration and passes it to the closure. Inside the closure, you can use the `Compiler`
+to drive queries to compile a crate and get the results. This is what the `rustc_driver` does too.
+You can see a minimal example of how to use `rustc_interface` [here][example].
+
+You can see what queries are currently available through the rustdocs for [`Compiler`].
+You can see an example of how to use them by looking at the `rustc_driver` implementation,
+specifically the [`rustc_driver::run_compiler` function][rd_rc] (not to be confused with
+[`rustc_interface::run_compiler`][i_rc]). The `rustc_driver::run_compiler` function
+takes a bunch of command-line args and some other configurations and
+drives the compilation to completion.
+
+`rustc_driver::run_compiler` also takes a [`Callbacks`][cb],
+a trait that allows for custom compiler configuration,
+as well as allowing some custom code run after different phases of the compilation.
+
+> **Warning:** By its very nature, the internal compiler APIs are always going
+> to be unstable. That said, we do try not to break things unnecessarily.
+
+
+[cb]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/trait.Callbacks.html
+[rd_rc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/fn.run_compiler.html
+[i_rc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/fn.run_compiler.html
+[example]: https://github.com/rust-lang/rustc-dev-guide/blob/master/examples/rustc-driver-example.rs
+[`rustc_interface`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/index.html
+[`rustc_driver`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/
+[`Compiler`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/struct.Compiler.html
+[`Session`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html
+[`TyCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html
+[`SourceMap`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/source_map/struct.SourceMap.html
+[stupid-stats]: https://github.com/nrc/stupid-stats
+[Appendix A]: appendix/stupid-stats.html
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals.md b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
new file mode 100644
index 000000000..91bb0c358
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
@@ -0,0 +1,242 @@
+# Rustdoc internals
+
+<!-- toc -->
+
+This page describes rustdoc's passes and modes. For an overview of rustdoc,
+see the ["Rustdoc overview" chapter](./rustdoc.md).
+
+## From crate to clean
+
+In `core.rs` are two central items: the `DocContext` struct, and the `run_core`
+function. The latter is where rustdoc calls out to rustc to compile a crate to
+the point where rustdoc can take over. The former is a state container used
+when crawling through a crate to gather its documentation.
+
+The main process of crate crawling is done in `clean/mod.rs` through several
+implementations of the `Clean` trait defined within. This is a conversion
+trait, which defines one method:
+
+```rust,ignore
+pub trait Clean<T> {
+    fn clean(&self, cx: &DocContext) -> T;
+}
+```
+
+`clean/mod.rs` also defines the types for the "cleaned" AST used later on to
+render documentation pages. Each usually accompanies an implementation of
+`Clean` that takes some AST or HIR type from rustc and converts it into the
+appropriate "cleaned" type. "Big" items like modules or associated items may
+have some extra processing in its `Clean` implementation, but for the most part
+these impls are straightforward conversions. The "entry point" to this module
+is the `impl Clean<Crate> for visit_ast::RustdocVisitor`, which is called by
+`run_core` above.
+
+You see, I actually lied a little earlier: There's another AST transformation
+that happens before the events in `clean/mod.rs`. In `visit_ast.rs` is the
+type `RustdocVisitor`, which *actually* crawls a `rustc_hir::Crate` to get the first
+intermediate representation, defined in `doctree.rs`. This pass is mainly to
+get a few intermediate wrappers around the HIR types and to process visibility
+and inlining. This is where `#[doc(inline)]`, `#[doc(no_inline)]`, and
+`#[doc(hidden)]` are processed, as well as the logic for whether a `pub use`
+should get the full page or a "Reexport" line in the module page.
+
+The other major thing that happens in `clean/mod.rs` is the collection of doc
+comments and `#[doc=""]` attributes into a separate field of the Attributes
+struct, present on anything that gets hand-written documentation. This makes it
+easier to collect this documentation later in the process.
+
+The primary output of this process is a `clean::Crate` with a tree of Items
+which describe the publicly-documentable items in the target crate.
+
+### Hot potato
+
+Before moving on to the next major step, a few important "passes" occur over
+the documentation. These do things like combine the separate "attributes" into
+a single string to make the document easier on the markdown parser,
+or drop items that are not public or deliberately hidden with `#[doc(hidden)]`.
+These are all implemented in the `passes/` directory, one file per pass.
+By default, all of these passes are run on a crate, but the ones
+regarding dropping private/hidden items can be bypassed by passing
+`--document-private-items` to rustdoc. Note that unlike the previous set of AST
+transformations, the passes are run on the _cleaned_ crate.
+
+(Strictly speaking, you can fine-tune the passes run and even add your own, but
+[we're trying to deprecate that][44136]. If you need finer-grain control over
+these passes, please let us know!)
+
+[44136]: https://github.com/rust-lang/rust/issues/44136
+
+Here is the list of passes as of <!-- date: 2022-05 --> May 2022:
+
+- `calculate-doc-coverage` calculates information used for the `--show-coverage`
+  flag.
+
+- `check-bare-urls` detects links that are not linkified, e.g., in Markdown such as
+  `Go to https://example.com/.` It suggests wrapping the link with angle brackets:
+  `Go to <https://example.com/>.` to linkify it. This is the code behind the <!--
+  date: 2022-05 --> `rustdoc::bare_urls` lint.
+
+- `check-code-block-syntax` validates syntax inside Rust code blocks
+  (<code>```rust</code>)
+
+- `check-doc-test-visibility` runs doctest visibility–related lints.
+
+- `check-invalid-html-tags` detects invalid HTML (like an unclosed `<span>`)
+  in doc comments.
+
+- `collect-intra-doc-links` resolves [intra-doc links](https://doc.rust-lang.org/nightly/rustdoc/write-documentation/linking-to-items-by-name.html).
+
+- `collect-trait-impls` collects trait impls for each item in the crate. For
+  example, if we define a struct that implements a trait, this pass will note
+  that the struct implements that trait.
+
+- `propagate-doc-cfg` propagates `#[doc(cfg(...))]` to child items.
+
+- `strip-priv-imports` strips all private import statements (`use`, `extern
+  crate`) from a crate. This is necessary because rustdoc will handle *public*
+  imports by either inlining the item's documentation to the module or creating
+  a "Reexports" section with the import in it. The pass ensures that all of
+  these imports are actually relevant to documentation.
+
+- `strip-hidden` and `strip-private` strip all `doc(hidden)` and private items
+  from the output. `strip-private` implies `strip-priv-imports`. Basically, the
+  goal is to remove items that are not relevant for public documentation.
+
+There is also a `stripper` module in `passes/`, but it is a collection of
+utility functions for the `strip-*` passes and is not a pass itself.
+
+## From clean to crate
+
+This is where the "second phase" in rustdoc begins. This phase primarily lives
+in the `html/` folder, and it all starts with `run()` in `html/render.rs`. This
+code is responsible for setting up the `Context`, `SharedContext`, and `Cache`
+which are used during rendering, copying out the static files which live in
+every rendered set of documentation (things like the fonts, CSS, and JavaScript
+that live in `html/static/`), creating the search index, and printing out the
+source code rendering, before beginning the process of rendering all the
+documentation for the crate.
+
+Several functions implemented directly on `Context` take the `clean::Crate` and
+set up some state between rendering items or recursing on a module's child
+items. From here the "page rendering" begins, via an enormous `write!()` call
+in `html/layout.rs`. The parts that actually generate HTML from the items and
+documentation occurs within a series of `std::fmt::Display` implementations and
+functions that pass around a `&mut std::fmt::Formatter`. The top-level
+implementation that writes out the page body is the `impl<'a> fmt::Display for
+Item<'a>` in `html/render.rs`, which switches out to one of several `item_*`
+functions based on the kind of `Item` being rendered.
+
+Depending on what kind of rendering code you're looking for, you'll probably
+find it either in `html/render.rs` for major items like "what sections should I
+print for a struct page" or `html/format.rs` for smaller component pieces like
+"how should I print a where clause as part of some other item".
+
+Whenever rustdoc comes across an item that should print hand-written
+documentation alongside, it calls out to `html/markdown.rs` which interfaces
+with the Markdown parser. This is exposed as a series of types that wrap a
+string of Markdown, and implement `fmt::Display` to emit HTML text. It takes
+special care to enable certain features like footnotes and tables and add
+syntax highlighting to Rust code blocks (via `html/highlight.rs`) before
+running the Markdown parser. There's also a function in here
+(`find_testable_code`) that specifically scans for Rust code blocks so the
+test-runner code can find all the doctests in the crate.
+
+### From soup to nuts
+
+(alternate title: ["An unbroken thread that stretches from those first `Cell`s
+to us"][video])
+
+[video]: https://www.youtube.com/watch?v=hOLAGYmUQV0
+
+It's important to note that the AST cleaning can ask the compiler for
+information (crucially, `DocContext` contains a `TyCtxt`), but page rendering
+cannot. The `clean::Crate` created within `run_core` is passed outside the
+compiler context before being handed to `html::render::run`. This means that a
+lot of the "supplementary data" that isn't immediately available inside an
+item's definition, like which trait is the `Deref` trait used by the language,
+needs to be collected during cleaning, stored in the `DocContext`, and passed
+along to the `SharedContext` during HTML rendering.  This manifests as a bunch
+of shared state, context variables, and `RefCell`s.
+
+Also of note is that some items that come from "asking the compiler" don't go
+directly into the `DocContext` - for example, when loading items from a foreign
+crate, rustdoc will ask about trait implementations and generate new `Item`s
+for the impls based on that information. This goes directly into the returned
+`Crate` rather than roundabout through the `DocContext`. This way, these
+implementations can be collected alongside the others, right before rendering
+the HTML.
+
+## Other tricks up its sleeve
+
+All this describes the process for generating HTML documentation from a Rust
+crate, but there are couple other major modes that rustdoc runs in. It can also
+be run on a standalone Markdown file, or it can run doctests on Rust code or
+standalone Markdown files. For the former, it shortcuts straight to
+`html/markdown.rs`, optionally including a mode which inserts a Table of
+Contents to the output HTML.
+
+For the latter, rustdoc runs a similar partial-compilation to get relevant
+documentation in `test.rs`, but instead of going through the full clean and
+render process, it runs a much simpler crate walk to grab *just* the
+hand-written documentation. Combined with the aforementioned
+"`find_testable_code`" in `html/markdown.rs`, it builds up a collection of
+tests to run before handing them off to the test runner. One notable
+location in `test.rs` is the function `make_test`, which is where hand-written
+doctests get transformed into something that can be executed.
+
+Some extra reading about `make_test` can be found
+[here](https://quietmisdreavus.net/code/2018/02/23/how-the-doctests-get-made/).
+
+## Dotting i's and crossing t's
+
+So that's rustdoc's code in a nutshell, but there's more things in the repo
+that deal with it. Since we have the full `compiletest` suite at hand, there's
+a set of tests in `src/test/rustdoc` that make sure the final HTML is what we
+expect in various situations. These tests also use a supplementary script,
+`src/etc/htmldocck.py`, that allows it to look through the final HTML using
+XPath notation to get a precise look at the output. The full description of all
+the commands available to rustdoc tests (e.g. [`@has`] and [`@matches`]) is in
+[`htmldocck.py`].
+
+To use multiple crates in a rustdoc test, add `// aux-build:filename.rs`
+to the top of the test file. `filename.rs` should be placed in an `auxiliary`
+directory relative to the test file with the comment. If you need to build
+docs for the auxiliary file, use `// build-aux-docs`.
+
+In addition, there are separate tests for the search index and rustdoc's
+ability to query it. The files in `src/test/rustdoc-js` each contain a
+different search query and the expected results, broken out by search tab.
+These files are processed by a script in `src/tools/rustdoc-js` and the Node.js
+runtime. These tests don't have as thorough of a writeup, but a broad example
+that features results in all tabs can be found in `basic.js`. The basic idea is
+that you match a given `QUERY` with a set of `EXPECTED` results, complete with
+the full item path of each item.
+
+[`htmldocck.py`]: https://github.com/rust-lang/rust/blob/master/src/etc/htmldocck.py
+[`@has`]: https://github.com/rust-lang/rust/blob/master/src/etc/htmldocck.py#L39
+[`@matches`]: https://github.com/rust-lang/rust/blob/master/src/etc/htmldocck.py#L44
+
+## Testing locally
+
+Some features of the generated HTML documentation might require local
+storage to be used across pages, which doesn't work well without an HTTP
+server. To test these features locally, you can run a local HTTP server, like
+this:
+
+```bash
+$ ./x.py doc library
+# The documentation has been generated into `build/[YOUR ARCH]/doc`.
+$ python3 -m http.server -d build/[YOUR ARCH]/doc
+```
+
+Now you can browse your documentation just like you would if it was hosted
+on the internet. For example, the url for `std` will be `/std/".
+
+## See also
+
+- The [`rustdoc` api docs]
+- [An overview of `rustdoc`](./rustdoc.md)
+- [The rustdoc user guide]
+
+[`rustdoc` api docs]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc/
+[The rustdoc user guide]: https://doc.rust-lang.org/nightly/rustdoc/
diff --git a/src/doc/rustc-dev-guide/src/rustdoc.md b/src/doc/rustc-dev-guide/src/rustdoc.md
new file mode 100644
index 000000000..4cdda5a3e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/rustdoc.md
@@ -0,0 +1,181 @@
+# Rustdoc overview
+
+`rustdoc` uses `rustc` internals (and, of course, the standard library), so you
+will have to build the compiler and `std` once before you can build `rustdoc`.
+
+`rustdoc` lives in-tree with the
+compiler and standard library. This chapter is about how it works.
+For information about Rustdoc's features and how to use them, see
+the [Rustdoc book](https://doc.rust-lang.org/nightly/rustdoc/).
+For more details about how rustdoc works, see the
+["Rustdoc internals" chapter][Rustdoc internals].
+
+[Rustdoc internals]: ./rustdoc-internals.md
+
+Rustdoc is implemented entirely within the crate [`librustdoc`][rd]. It runs
+the compiler up to the point where we have an internal representation of a
+crate (HIR) and the ability to run some queries about the types of items. [HIR]
+and [queries] are discussed in the linked chapters.
+
+[HIR]: ./hir.md
+[queries]: ./query.md
+[rd]: https://github.com/rust-lang/rust/tree/master/src/librustdoc
+
+`librustdoc` performs two major steps after that to render a set of
+documentation:
+
+* "Clean" the AST into a form that's more suited to creating documentation (and
+  slightly more resistant to churn in the compiler).
+* Use this cleaned AST to render a crate's documentation, one page at a time.
+
+Naturally, there's more than just this, and those descriptions simplify out
+lots of details, but that's the high-level overview.
+
+(Side note: `librustdoc` is a library crate! The `rustdoc` binary is created
+using the project in [`src/tools/rustdoc`][bin]. Note that literally all that
+does is call the `main()` that's in this crate's `lib.rs`, though.)
+
+[bin]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
+
+## Cheat sheet
+
+* Run `./x.py setup tools` before getting started. This will configure `x.py`
+  with nice settings for developing rustdoc and other tools, including
+  downloading a copy of rustc rather than building it.
+* Use `./x.py check src/tools/rustdoc` to quickly check for compile errors.
+* Use `./x.py build` to make a usable
+  rustdoc you can run on other projects.
+  * Add `library/test` to be able to use `rustdoc --test`.
+  * Run `rustup toolchain link stage2 build/$TARGET/stage2` to add a
+    custom toolchain called `stage2` to your rustup environment. After
+    running that, `cargo +stage2 doc` in any directory will build with
+    your locally-compiled rustdoc.
+* Use `./x.py doc library` to use this rustdoc to generate the
+  standard library docs.
+  * The completed docs will be available in `build/$TARGET/doc` (under `core`, `alloc`, and `std`).
+  * If you want to copy those docs to a webserver, copy all of
+    `build/$TARGET/doc`, since that's where the CSS, JS, fonts, and landing
+    page are.
+* Use `./x.py test src/test/rustdoc*` to run the tests using a stage1
+  rustdoc.
+  * See [Rustdoc internals] for more information about tests.
+
+## Code structure
+
+* All paths in this section are relative to `src/librustdoc` in the rust-lang/rust repository.
+* Most of the HTML printing code is in `html/format.rs` and `html/render/mod.rs`.
+  It's in a bunch of `fmt::Display` implementations and supplementary
+  functions.
+* The types that got `Display` impls above are defined in `clean/mod.rs`, right
+  next to the custom `Clean` trait used to process them out of the rustc HIR.
+* The bits specific to using rustdoc as a test harness are in
+  `doctest.rs`.
+* The Markdown renderer is loaded up in `html/markdown.rs`, including functions
+  for extracting doctests from a given block of Markdown.
+* The tests on the structure of rustdoc HTML output are located in `src/test/rustdoc`, where
+  they're handled by the test runner of rustbuild and the supplementary script
+  `src/etc/htmldocck.py`.
+
+## Tests
+
+* All paths in this section are relative to `src/test` in the rust-lang/rust repository.
+* Tests on search index generation are located in `rustdoc-js`, as a
+  series of JavaScript files that encode queries on the standard library search
+  index and expected results.
+* Tests on the "UI" of rustdoc (the terminal output it produces when run) are in
+  `rustdoc-ui`
+* Tests on the "GUI" of rustdoc (the HTML, JS, and CSS as rendered in a browser)
+  are in `rustdoc-gui`. These use a [NodeJS tool called
+  browser-UI-test](https://github.com/GuillaumeGomez/browser-UI-test/) that uses
+  puppeteer to run tests in a headless browser and check rendering and
+  interactivity.
+
+## Constraints
+
+We try to make rustdoc work reasonably well with JavaScript disabled, and when
+browsing local files. We support
+[these browsers](https://rust-lang.github.io/rfcs/1985-tiered-browser-support.html#supported-browsers).
+
+Supporting local files (`file:///` URLs) brings some surprising restrictions.
+Certain browser features that require secure origins, like `localStorage` and
+Service Workers, don't work reliably. We can still use such features but we
+should make sure pages are still usable without them.
+
+## Multiple runs, same output directory
+
+Rustdoc can be run multiple times for varying inputs, with its output set to the
+same directory. That's how cargo produces documentation for dependencies of the
+current crate. It can also be done manually if a user wants a big
+documentation bundle with all of the docs they care about.
+
+HTML is generated independently for each crate, but there is some cross-crate
+information that we update as we add crates to the output directory:
+
+ - `crates<SUFFIX>.js` holds a list of all crates in the output directory.
+ - `search-index<SUFFIX>.js` holds a list of all searchable items.
+ - For each trait, there is a file under `implementors/.../trait.TraitName.js`
+   containing a list of implementors of that trait. The implementors may be in
+   different crates than the trait, and the JS file is updated as we discover
+   new ones.
+
+## Use cases
+
+There are a few major use cases for rustdoc that you should keep in mind when
+working on it:
+
+### Standard library docs
+
+These are published at <https://doc.rust-lang.org/std> as part of the Rust release
+process. Stable releases are also uploaded to specific versioned URLs like
+<https://doc.rust-lang.org/1.57.0/std/>. Beta and nightly docs are published to
+<https://doc.rust-lang.org/beta/std/> and <https://doc.rust-lang.org/nightly/std/>.
+The docs are uploaded with the [promote-release
+tool](https://github.com/rust-lang/promote-release) and served from S3 with
+CloudFront.
+
+The standard library docs contain five crates: alloc, core, proc_macro, std, and
+test.
+
+### docs.rs
+
+When crates are published to crates.io, docs.rs automatically builds
+and publishes their documentation, for instance at
+<https://docs.rs/serde/latest/serde/>. It always builds with the current nightly
+rustdoc, so any changes you land in rustdoc are "insta-stable" in that they will
+have an immediate public effect on docs.rs. Old documentation is not rebuilt, so
+you will see some variation in UI when browsing old releases in docs.rs. Crate
+authors can request rebuilds, which will be run with the latest rustdoc.
+
+Docs.rs performs some transformations on rustdoc's output in order to save
+storage and display a navigation bar at the top. In particular, certain static
+files (like main.js and rustdoc.css may be shared across multiple invocations
+of the same version of rustdoc. Others, like crates.js and sidebar-items.js, are
+different for different invocations. Still others, like fonts, will never
+change. These categories are distinguished using the `SharedResource` enum in
+`src/librustdoc/html/render/write_shared.rs`
+
+Documentation on docs.rs is always generated for a single crate at a time, so
+the search and sidebar functionality don't include dependencies of the current
+crate.
+
+### Locally generated docs
+
+Crate authors can run `cargo doc --open` in crates they have checked
+out locally to see the docs. This is useful to check that the docs they
+are writing are useful and display correctly. It can also be useful for
+people to view documentation on crates they aren't authors of, but want to
+use. In both cases, people may use `--document-private-items` Cargo flag to
+see private methods, fields, and so on, which are normally not displayed.
+
+By default `cargo doc` will generate documentation for a crate and all of its
+dependencies. That can result in a very large documentation bundle, with a large
+(and slow) search corpus. The Cargo flag `--no-deps` inhibits that behavior and
+generates docs for just the crate.
+
+### Self-hosted project docs
+
+Some projects like to host their own documentation. For example:
+<https://docs.serde.rs/>. This is easy to do by locally generating docs, and
+simply copying them to a web server. Rustdoc's HTML output can be extensively
+customized by flags. Users can add a theme, set the default theme, and inject
+arbitrary HTML. See `rustdoc --help` for details.
diff --git a/src/doc/rustc-dev-guide/src/salsa.md b/src/doc/rustc-dev-guide/src/salsa.md
new file mode 100644
index 000000000..afa01eda2
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/salsa.md
@@ -0,0 +1,218 @@
+# How Salsa works
+
+<!-- toc -->
+
+This chapter is based on the explanation given by Niko Matsakis in this
+[video](https://www.youtube.com/watch?v=_muY4HjSqVw) about
+[Salsa](https://github.com/salsa-rs/salsa). To find out more you may
+want to watch [Salsa In More
+Depth](https://www.youtube.com/watch?v=i_IhACacPRY), also by Niko
+Matsakis.
+
+> As of <!-- date: 2022-04 --> April 2022, although Salsa is inspired by
+> (among other things) rustc's query system, it is not used directly in rustc.
+> It _is_ used in chalk and extensively in `rust-analyzer`, but there are no
+> medium or long-term concrete plans to integrate it into the compiler.
+
+## What is Salsa?
+
+Salsa is a library for incremental recomputation. This means it allows reusing
+computations that were already done in the past to increase the efficiency
+of future computations.
+
+The objectives of Salsa are:
+ * Provide that functionality in an automatic way, so reusing old computations
+   is done automatically by the library
+ * Doing so in a "sound", or "correct", way, therefore leading to the same
+   results as if it had been done from scratch
+
+Salsa's actual model is much richer, allowing many kinds of inputs and many
+different outputs.
+For example, integrating Salsa with an IDE could mean that the inputs could be
+the manifest (`Cargo.toml`), entire source files (`foo.rs`), snippets and so
+on; the outputs of such an integration could range from a binary executable, to
+lints, types (for example, if a user selects a certain variable and wishes to
+see its type), completions, etc.
+
+## How does it work?
+
+The first thing that Salsa has to do is identify the "base inputs" that
+are not something computed but given as input.
+
+Then Salsa has to also identify intermediate, "derived" values, which are
+something that the library produces, but, for each derived value there's a
+"pure" function that computes the derived value.
+
+For example, there might be a function `ast(x: Path) -> AST`. The produced
+`AST` isn't a final value, it's an intermediate value that the library would
+use for the computation.
+
+This means that when you try to compute with the library, Salsa is going to
+compute various derived values, and eventually read the input and produce the
+result for the asked computation.
+
+In the course of computing, Salsa tracks which inputs were accessed and which
+values are derived. This information is used to determine what's going to
+happen when the inputs change: are the derived values still valid?
+
+This doesn't necessarily mean that each computation downstream from the input
+is going to be checked, which could be costly. Salsa only needs to check each
+downstream computation until it finds one that isn't changed. At that point, it
+won't check other derived computations since they wouldn't need to change.
+
+It's helpful to think about this as a graph with nodes. Each derived value
+has a dependency on other values, which could themselves be either base or
+derived. Base values don't have a dependency.
+
+```ignore
+I <- A <- C ...
+          |
+J <- B <--+
+```
+
+When an input `I` changes, the derived value `A` could change. The derived
+value `B`, which does not depend on `I`, `A`, or any value derived from `A` or
+`I`, is not subject to change.  Therefore, Salsa can reuse the computation done
+for `B` in the past, without having to compute it again.
+
+The computation could also terminate early. Keeping the same graph as before,
+say that input `I` has changed in some way (and input `J` hasn't), but when
+computing `A` again, it's found that `A` hasn't changed from the previous
+computation. This leads to an "early termination", because there's no need to
+check if `C` needs to change, since both `C` direct inputs, `A` and `B`,
+haven't changed.
+
+## Key Salsa concepts
+
+### Query
+
+A query is some value that Salsa can access in the course of computation.  Each
+query can have a number of keys (from 0 to many), and all queries have a
+result, akin to functions.  0-key queries are called "input" queries.
+
+### Database
+
+The database is basically the context for the entire computation, it's meant to
+store Salsa's internal state, all intermediate values for each query, and
+anything else that the computation might need.  The database must know all the
+queries that the library is going to do before it can be built, but they don't
+need to be specified in the same place.
+
+After the database is formed, it can be accessed with queries that are very
+similar to functions.  Since each query's result is stored in the database,
+when a query is invoked N times, it will return N **cloned** results, without
+having to recompute the query (unless the input has changed in such a way that
+it warrants recomputation).
+
+For each input query (0-key), a "set" method is generated, allowing the user to
+change the output of such query, and trigger previous memoized values to be
+potentially invalidated.
+
+### Query Groups
+
+A query group is a set of queries which have been defined together as a unit.
+The database is formed by combining query groups. Query groups are akin to
+"Salsa modules".
+
+A set of queries in a query group are just a set of methods in a trait.
+
+To create a query group a trait annotated with a specific attribute
+(`#[salsa::query_group(...)]`) has to be created.
+
+An argument must also be provided to said attribute as it will be used by Salsa
+to create a struct to be used later when the database is created.
+
+Example input query group:
+
+```rust,ignore
+/// This attribute will process this tree, produce this tree as output, and produce
+/// a bunch of intermediate stuff that Salsa also uses.  One of these things is a
+/// "StorageStruct", whose name we have specified in the attribute.
+///
+/// This query group is a bunch of **input** queries, that do not rely on any
+/// derived input.
+#[salsa::query_group(InputsStorage)]
+pub trait Inputs {
+    /// This attribute (`#[salsa::input]`) indicates that this query is a base
+    /// input, therefore `set_manifest` is going to be auto-generated
+    #[salsa::input]
+    fn manifest(&self) -> Manifest;
+
+    #[salsa::input]
+    fn source_text(&self, name: String) -> String;
+}
+```
+
+To create a **derived** query group, one must specify which other query groups
+this one depends on by specifying them as supertraits, as seen in the following
+example:
+
+```rust,ignore
+/// This query group is going to contain queries that depend on derived values a
+/// query group can access another query group's queries by specifying the
+/// dependency as a super trait query groups can be stacked as much as needed using
+/// that pattern.
+#[salsa::query_group(ParserStorage)]
+pub trait Parser: Inputs {
+    /// This query `ast` is not an input query, it's a derived query this means
+    /// that a definition is necessary.
+    fn ast(&self, name: String) -> String;
+}
+```
+
+When creating a derived query the implementation of said query must be defined
+outside the trait.  The definition must take a database parameter as an `impl
+Trait` (or `dyn Trait`), where `Trait` is the query group that the definition
+belongs to, in addition to the other keys.
+
+```rust,ignore
+///This is going to be the definition of the `ast` query in the `Parser` trait.
+///So, when the query `ast` is invoked, and it needs to be recomputed, Salsa is going to call this function
+///and it's is going to give it the database as `impl Parser`.
+///The function doesn't need to be aware of all the queries of all the query groups
+fn ast(db: &impl Parser, name: String) -> String {
+    //! Note, `impl Parser` is used here but `dyn Parser` works just as well
+    /* code */
+    ///By passing an `impl Parser`, this is allowed
+    let source_text = db.input_file(name);
+    /* do the actual parsing */
+    return ast;
+}
+```
+
+Eventually, after all the query groups have been defined, the database can be
+created by declaring a struct.
+
+To specify which query groups are going to be part of the database an attribute
+(`#[salsa::database(...)]`) must be added. The argument of said attribute is a
+list of identifiers, specifying the query groups **storages**.
+
+```rust,ignore
+///This attribute specifies which query groups are going to be in the database
+#[salsa::database(InputsStorage, ParserStorage)]
+#[derive(Default)] //optional!
+struct MyDatabase {
+    ///You also need this one field
+    runtime : salsa::Runtime<MyDatabase>,
+}
+///And this trait has to be implemented
+impl salsa::Database for MyDatabase {
+    fn salsa_runtime(&self) -> &salsa::Runtime<MyDatabase> {
+        &self.runtime
+    }
+}
+```
+
+Example usage:
+
+```rust,ignore
+fn main() {
+    let db = MyDatabase::default();
+    db.set_manifest(...);
+    db.set_source_text(...);
+    loop {
+        db.ast(...); //will reuse results
+        db.set_source_text(...);
+    }
+}
+```
diff --git a/src/doc/rustc-dev-guide/src/sanitizers.md b/src/doc/rustc-dev-guide/src/sanitizers.md
new file mode 100644
index 000000000..a088d62ed
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/sanitizers.md
@@ -0,0 +1,121 @@
+# Sanitizers Support
+
+The rustc compiler contains support for following sanitizers:
+
+* [AddressSanitizer][clang-asan] a faster memory error detector. Can
+  detect out-of-bounds access to heap, stack, and globals, use after free, use
+  after return, double free, invalid free, memory leaks.
+* [ControlFlowIntegrity][clang-cfi] LLVM Control Flow Integrity (CFI) provides
+  forward-edge control flow protection.
+* [Hardware-assisted AddressSanitizer][clang-hwasan]  a tool similar to
+  AddressSanitizer but based on partial hardware assistance.
+* [LeakSanitizer][clang-lsan] a run-time memory leak detector.
+* [MemorySanitizer][clang-msan] a detector of uninitialized reads.
+* [ThreadSanitizer][clang-tsan] a fast data race detector.
+
+## How to use the sanitizers?
+
+To enable a sanitizer compile with `-Z sanitizer=...` option, where value is one
+of `address`, `cfi`, `hwaddress`, `leak`, `memory` or `thread`. For more details
+on how to use sanitizers please refer to the sanitizer flag in [the unstable
+book](https://doc.rust-lang.org/unstable-book/).
+
+## How are sanitizers implemented in rustc?
+
+The implementation of sanitizers (except CFI) relies almost entirely on LLVM.
+The rustc is an integration point for LLVM compile time instrumentation passes
+and runtime libraries. Highlight of the most important aspects of the
+implementation:
+
+*  The sanitizer runtime libraries are part of the [compiler-rt] project, and
+   [will be built][sanitizer-build] on [supported targets][sanitizer-targets]
+   when enabled in `config.toml`:
+
+   ```toml
+   [build]
+   sanitizers = true
+   ```
+
+   The runtimes are [placed into target libdir][sanitizer-copy].
+
+*  During LLVM code generation, the functions intended for instrumentation are
+   [marked][sanitizer-attribute] with appropriate LLVM attribute:
+   `SanitizeAddress`, `SanitizeHWAddress`, `SanitizeMemory`, or
+   `SanitizeThread`. By default all functions are instrumented, but this
+   behaviour can be changed with `#[no_sanitize(...)]`.
+
+*  The decision whether to perform instrumentation or not is possible only at a
+   function granularity. In the cases were those decision differ between
+   functions it might be necessary to inhibit inlining, both at [MIR
+   level][inline-mir] and [LLVM level][inline-llvm].
+
+*  The LLVM IR generated by rustc is instrumented by [dedicated LLVM
+   passes][sanitizer-pass], different for each sanitizer. Instrumentation
+   passes are invoked after optimization passes.
+
+*  When producing an executable, the sanitizer specific runtime library is
+   [linked in][sanitizer-link]. The libraries are searched for in the target
+   libdir. First relative to the overridden system root and subsequently
+   relative to the default system root. Fall-back to the default system root
+   ensures that sanitizer runtimes remain available when using sysroot overrides
+   constructed by cargo `-Z build-std` or xargo.
+
+[compiler-rt]: https://github.com/llvm/llvm-project/tree/main/compiler-rt
+[sanitizer-build]: https://github.com/rust-lang/rust/blob/1.55.0/src/bootstrap/native.rs#L700-L765
+[sanitizer-targets]: https://github.com/rust-lang/rust/blob/1.55.0/src/bootstrap/native.rs#L806-L820
+[sanitizer-copy]: https://github.com/rust-lang/rust/blob/1.55.0/src/bootstrap/compile.rs#L376-L407
+[sanitizer-attribute]: https://github.com/rust-lang/rust/blob/1.55.0/compiler/rustc_codegen_llvm/src/attributes.rs#L42-L58
+[inline-mir]: https://github.com/rust-lang/rust/blob/1.55.0/compiler/rustc_mir/src/transform/inline.rs#L314-L316
+[inline-llvm]: https://github.com/rust-lang/llvm-project/blob/9330ec5a4c1df5fc1fa62f993ed6a04da68cb040/llvm/include/llvm/IR/Attributes.td#L225-L241
+[sanitizer-pass]: https://github.com/rust-lang/rust/blob/1.55.0/compiler/rustc_codegen_llvm/src/back/write.rs#L660-L678
+[sanitizer-link]: https://github.com/rust-lang/rust/blob/1.55.0/compiler/rustc_codegen_ssa/src/back/link.rs#L1053-L1089
+
+## Testing sanitizers
+
+Sanitizers are validated by code generation tests in
+[`src/test/codegen/sanitize*.rs`][test-cg] and end-to-end functional tests in
+[`src/test/ui/sanitize/`][test-ui] directory.
+
+Testing sanitizer functionality requires the sanitizer runtimes (built when
+`sanitizer = true` in `config.toml`) and target providing support for particular
+sanitizer. When sanitizer is unsupported on given target, sanitizers tests will
+be ignored. This behaviour is controlled by compiletest `needs-sanitizer-*`
+directives.
+
+[test-cg]: https://github.com/rust-lang/rust/tree/master/src/test/codegen
+[test-ui]: https://github.com/rust-lang/rust/tree/master/src/test/ui/sanitize
+
+## Enabling sanitizer on a new target
+
+To enable a sanitizer on a new target which is already supported by LLVM:
+
+1. Include the sanitizer in the list of `supported_sanitizers` in [the target
+   definition][target-definition]. `rustc --target .. -Zsanitizer=..` should now
+   recognize sanitizer as supported.
+2. [Build the runtime for the target and include it in the libdir.][sanitizer-targets]
+3. [Teach compiletest that your target now supports the sanitizer.][compiletest-definition]
+   Tests marked with `needs-sanitizer-*` should now run on the target.
+4. Run tests `./x.py test --force-rerun src/test/ui/sanitize/` to verify.
+5. [--enable-sanitizers in the CI configuration][ci-configuration] to build and
+   distribute the sanitizer runtime as part of the release process.
+
+[target-definition]: https://github.com/rust-lang/rust/blob/1.55.0/compiler/rustc_target/src/spec/x86_64_unknown_linux_gnu.rs#L10-L11
+[compiletest-definition]: https://github.com/rust-lang/rust/blob/1.55.0/src/tools/compiletest/src/util.rs#L87-L116
+[ci-configuration]: https://github.com/rust-lang/rust/blob/1.55.0/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile#L94
+
+## Additional Information
+
+* [Sanitizers project page](https://github.com/google/sanitizers/wiki/)
+* [AddressSanitizer in Clang][clang-asan]
+* [ControlFlowIntegrity in Clang][clang-cfi]
+* [Hardware-assisted AddressSanitizer][clang-hwasan]
+* [LeakSanitizer in Clang][clang-lsan]
+* [MemorySanitizer in Clang][clang-msan]
+* [ThreadSanitizer in Clang][clang-tsan]
+
+[clang-asan]: https://clang.llvm.org/docs/AddressSanitizer.html
+[clang-cfi]: https://clang.llvm.org/docs/ControlFlowIntegrity.html
+[clang-hwasan]: https://clang.llvm.org/docs/HardwareAssistedAddressSanitizerDesign.html
+[clang-lsan]: https://clang.llvm.org/docs/LeakSanitizer.html
+[clang-msan]: https://clang.llvm.org/docs/MemorySanitizer.html
+[clang-tsan]: https://clang.llvm.org/docs/ThreadSanitizer.html
diff --git a/src/doc/rustc-dev-guide/src/serialization.md b/src/doc/rustc-dev-guide/src/serialization.md
new file mode 100644
index 000000000..5d8434b55
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/serialization.md
@@ -0,0 +1,166 @@
+# Serialization in Rustc
+
+Rustc has to [serialize] and deserialize various data during compilation.
+Specifically:
+
+- "Crate metadata", mainly query outputs, are serialized in a binary
+  format into `rlib` and `rmeta` files that are output when compiling a library
+  crate, these are then deserialized by crates that depend on that library.
+- Certain query outputs are serialized in a binary format to
+  [persist incremental compilation results].
+- The `-Z ast-json` and `-Z ast-json-noexpand` flags serialize the [AST] to json
+  and output the result to stdout.
+- [`CrateInfo`] is serialized to json when the `-Z no-link` flag is used, and
+  deserialized from json when the `-Z link-only` flag is used.
+
+## The `Encodable` and `Decodable` traits
+
+The [`rustc_serialize`] crate defines two traits for types which can be serialized:
+
+```rust,ignore
+pub trait Encodable<S: Encoder> {
+    fn encode(&self, s: &mut S) -> Result<(), S::Error>;
+}
+
+pub trait Decodable<D: Decoder>: Sized {
+    fn decode(d: &mut D) -> Result<Self, D::Error>;
+}
+```
+
+It also defines implementations of these for integer types, floating point
+types, `bool`, `char`, `str` and various common standard library types.
+
+For types that are constructed from those types, `Encodable` and `Decodable` are
+usually implemented by [derives]. These generate implementations that forward
+deserialization to the fields of the struct or enum. For a struct those impls
+look something like this:
+
+```rust,ignore
+#![feature(rustc_private)]
+extern crate rustc_serialize;
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+
+struct MyStruct {
+    int: u32,
+    float: f32,
+}
+
+impl<E: Encoder> Encodable<E> for MyStruct {
+    fn encode(&self, s: &mut E) -> Result<(), E::Error> {
+        s.emit_struct("MyStruct", 2, |s| {
+            s.emit_struct_field("int", 0, |s| self.int.encode(s))?;
+            s.emit_struct_field("float", 1, |s| self.float.encode(s))
+        })
+    }
+}
+impl<D: Decoder> Decodable<D> for MyStruct {
+    fn decode(s: &mut D) -> Result<MyStruct, D::Error> {
+        s.read_struct("MyStruct", 2, |d| {
+            let int = d.read_struct_field("int", 0, Decodable::decode)?;
+            let float = d.read_struct_field("float", 1, Decodable::decode)?;
+
+            Ok(MyStruct { int, float })
+        })
+    }
+}
+```
+
+## Encoding and Decoding arena allocated types
+
+Rustc has a lot of [arena allocated types]. Deserializing these types isn't
+possible without access to the arena that they need to be allocated on. The
+[`TyDecoder`] and [`TyEncoder`] traits are supertraits of `Decoder` and
+`Encoder` that allow access to a `TyCtxt`.
+
+Types which contain arena allocated types can then bound the type parameter of
+their `Encodable` and `Decodable` implementations with these traits. For
+example
+
+```rust,ignore
+impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for MyStruct<'tcx> {
+    /* ... */
+}
+```
+
+The `TyEncodable` and `TyDecodable` [derive macros][derives] will expand to such
+an implementation.
+
+Decoding the actual arena allocated type is harder, because some of the
+implementations can't be written due to the orphan rules. To work around this,
+the [`RefDecodable`] trait is defined in `rustc_middle`. This can then be
+implemented for any type. The `TyDecodable` macro will call `RefDecodable` to
+decode references, but various generic code needs types to actually be
+`Decodable` with a specific decoder.
+
+For interned types instead of manually implementing `RefDecodable`, using a new
+type wrapper, like `ty::Predicate` and manually implementing `Encodable` and
+`Decodable` may be simpler.
+
+## Derive macros
+
+The `rustc_macros` crate defines various derives to help implement `Decodable`
+and `Encodable`.
+
+- The `Encodable` and `Decodable` macros generate implementations that apply to
+  all `Encoders` and `Decoders`. These should be used in crates that don't
+  depend on `rustc_middle`, or that have to be serialized by a type that does
+  not implement `TyEncoder`.
+- `MetadataEncodable` and `MetadataDecodable` generate implementations that
+  only allow decoding by [`rustc_metadata::rmeta::encoder::EncodeContext`] and
+  [`rustc_metadata::rmeta::decoder::DecodeContext`]. These are used for types
+  that contain `rustc_metadata::rmeta::Lazy`.
+- `TyEncodable` and `TyDecoder` generate implementation that apply to any
+  `TyEncoder` or `TyDecoder`. These should be used for types that are only
+  serialized in crate metadata and/or the incremental cache, which is most
+  serializable types in `rustc_middle`.
+
+## Shorthands
+
+`Ty` can be deeply recursive, if each `Ty` was encoded naively then crate
+metadata would be very large. To handle this, each `TyEncoder` has a cache of
+locations in its output where it has serialized types. If a type being encoded
+is in the cache, then instead of serializing the type as usual, the byte offset
+within the file being written is encoded instead. A similar scheme is used for
+`ty::Predicate`.
+
+## `LazyValue<T>`
+
+Crate metadata is initially loaded before the `TyCtxt<'tcx>` is created, so
+some deserialization needs to be deferred from the initial loading of metadata.
+The [`LazyValue<T>`] type wraps the (relative) offset in the crate metadata where a
+`T` has been serialized. There are also some variants, [`LazyArray<T>`] and [`LazyTable<I, T>`].
+
+The `Lazy<[T]>` and `LazyTable<I, T>` type provide some functionality over
+`Lazy<Vec<T>>` and `Lazy<HashMap<I, T>>`:
+
+- It's possible to encode a `LazyArray<T>` directly from an iterator, without
+  first collecting into a `Vec<T>`.
+- Indexing into a `LazyTable<I, T>` does not require decoding entries other
+  than the one being read.
+
+**note**: `LazyValue<T>` does not cache its value after being deserialized the first
+time. Instead the query system is the main way of caching these results.
+
+## Specialization
+
+A few types, most notably `DefId`, need to have different implementations for
+different `Encoder`s. This is currently handled by ad-hoc specializations:
+`DefId` has a `default` implementation of `Encodable<E>` and a specialized one
+for `Encodable<CacheEncoder>`.
+
+[arena allocated types]: memory.md
+[AST]: the-parser.md
+[derives]: #derive-macros
+[persist incremental compilation results]: queries/incremental-compilation-in-detail.md#the-real-world-how-persistence-makes-everything-complicated
+[serialize]: https://en.wikipedia.org/wiki/Serialization
+
+[`CrateInfo`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/struct.CrateInfo.html
+[`LazyArray<T>`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/struct.LazyValue.html
+[`LazyTable<I, T>`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/struct.LazyValue.html
+[`LazyValue<T>`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/struct.LazyValue.html
+[`RefDecodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/codec/trait.RefDecodable.html
+[`rustc_metadata::rmeta::decoder::DecodeContext`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/decoder/struct.DecodeContext.html
+[`rustc_metadata::rmeta::encoder::EncodeContext`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/encoder/struct.EncodeContext.html
+[`rustc_serialize`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_serialize/index.html
+[`TyDecoder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/codec/trait.TyEncoder.html
+[`TyEncoder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/codec/trait.TyDecoder.html
diff --git a/src/doc/rustc-dev-guide/src/stability.md b/src/doc/rustc-dev-guide/src/stability.md
new file mode 100644
index 000000000..3469ce2ba
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/stability.md
@@ -0,0 +1,155 @@
+# Stability attributes
+
+<!-- toc -->
+
+This section is about the stability attributes and schemes that allow stable
+APIs to use unstable APIs internally in the rustc standard library.
+
+For instructions on stabilizing a language feature see [Stabilizing
+Features](./stabilization_guide.md).
+
+## unstable
+
+The `#[unstable(feature = "foo", issue = "1234", reason = "lorem ipsum")]`
+attribute explicitly marks an item as unstable. Items that are marked as
+"unstable" cannot be used without a corresponding `#![feature]` attribute on
+the crate, even on a nightly compiler. This restriction only applies across
+crate boundaries, unstable items may be used within the crate that defines
+them.
+
+The `issue` field specifies the associated GitHub [issue number]. This field is
+required and all unstable features should have an associated tracking issue. In
+rare cases where there is no sensible value `issue = "none"` is used.
+
+The `unstable` attribute infects all sub-items, where the attribute doesn't
+have to be reapplied. So if you apply this to a module, all items in the module
+will be unstable.
+
+You can make specific sub-items stable by using the `#[stable]` attribute on
+them. The stability scheme works similarly to how `pub` works. You can have
+public functions of nonpublic modules and you can have stable functions in
+unstable modules or vice versa.
+
+Note, however, that due to a [rustc bug], stable items inside unstable modules
+*are* available to stable code in that location!  So, for example, stable code
+can import `core::intrinsics::transmute` even though `intrinsics` is an
+unstable module.  Thus, this kind of nesting should be avoided when possible.
+
+The `unstable` attribute may also have the `soft` value, which makes it a
+future-incompatible deny-by-default lint instead of a hard error. This is used
+by the `bench` attribute which was accidentally accepted in the past. This
+prevents breaking dependencies by leveraging Cargo's lint capping.
+
+[issue number]: https://github.com/rust-lang/rust/issues
+[rustc bug]: https://github.com/rust-lang/rust/issues/15702
+
+## stable
+The `#[stable(feature = "foo", since = "1.420.69")]` attribute explicitly
+marks an item as stabilized. Note that stable functions may use unstable things in their body.
+
+## rustc_const_unstable
+
+The `#[rustc_const_unstable(feature = "foo", issue = "1234", reason = "lorem ipsum")]`
+has the same interface as the `unstable` attribute. It is used to mark
+`const fn` as having their constness be unstable. This allows you to make a
+function stable without stabilizing its constness or even just marking an existing
+stable function as `const fn` without instantly stabilizing the `const fn`ness.
+
+Furthermore this attribute is needed to mark an intrinsic as `const fn`, because
+there's no way to add `const` to functions in `extern` blocks for now.
+
+## rustc_const_stable
+
+The `#[rustc_const_stable(feature = "foo", since = "1.420.69")]` attribute explicitly marks
+a `const fn` as having its constness be `stable`. This attribute can make sense
+even on an `unstable` function, if that function is called from another
+`rustc_const_stable` function.
+
+Furthermore this attribute is needed to mark an intrinsic as callable from
+`rustc_const_stable` functions.
+
+## Stabilizing a library feature
+
+To stabilize a feature, follow these steps:
+
+0. Ask a **@T-libs-api** member to start an FCP on the tracking issue and wait for
+   the FCP to complete (with `disposition-merge`).
+1. Change `#[unstable(...)]` to `#[stable(since = "version")]`.
+   `version` should be the *current nightly*, i.e. stable+2. You can see which version is
+   the current nightly [on Forge](https://forge.rust-lang.org/#current-release-versions).
+2. Remove `#![feature(...)]` from any test or doc-test for this API. If the feature is used in the
+   compiler or tools, remove it from there as well.
+3. If applicable, change `#[rustc_const_unstable(...)]` to
+   `#[rustc_const_stable(since = "version")]`.
+4. Open a PR against `rust-lang/rust`.
+   - Add the appropriate labels: `@rustbot modify labels: +T-libs-api`.
+   - Link to the tracking issue and say "Closes #XXXXX".
+
+You can see an example of stabilizing a feature with
+[tracking issue #81656 with FCP](https://github.com/rust-lang/rust/issues/81656)
+and the associated
+[implementation PR #84642](https://github.com/rust-lang/rust/pull/84642).
+
+## allow_internal_unstable
+
+Macros and compiler desugarings expose their bodies to the call
+site. To work around not being able to use unstable things in the standard
+library's macros, there's the `#[allow_internal_unstable(feature1, feature2)]`
+attribute that allows the given features to be used in stable macros.
+
+## rustc_allow_const_fn_unstable
+
+`const fn`, while not directly exposing their body to the world, are going to get
+evaluated at compile time in stable crates. If their body does something const-unstable,
+that could lock us into certain features indefinitely by accident. Thus no unstable const
+features are allowed inside stable `const fn`.
+
+However, sometimes we do know that a feature will get
+stabilized, just not when, or there is a stable (but e.g. runtime-slow) workaround, so we
+could always fall back to some stable version if we scrapped the unstable feature.
+In those cases, the rustc_allow_const_fn_unstable attribute can be used to allow some
+unstable features in the body of a stable `const fn`.
+
+You also need to take care to uphold the `const fn` invariant that calling it at runtime and
+compile-time needs to behave the same (see also [this blog post][blog]). This means that you
+may not create a `const fn` that e.g. transmutes a memory address to an integer,
+because the addresses of things are nondeterministic and often unknown at
+compile-time.
+
+Always ping @rust-lang/wg-const-eval if you are adding more
+`rustc_allow_const_fn_unstable` attributes to any `const fn`.
+
+## staged_api
+
+Any crate that uses the `stable` or `unstable` attributes must include the
+`#![feature(staged_api)]` attribute on the crate.
+
+## deprecated
+
+Deprecations in the standard library are nearly identical to deprecations in
+user code. When `#[deprecated]` is used on an item, it must also have a `stable`
+or `unstable `attribute.
+
+`deprecated` has the following form:
+
+```rust,ignore
+#[deprecated(
+    since = "1.38.0",
+    note = "explanation for deprecation",
+    suggestion = "other_function"
+)]
+```
+
+The `suggestion` field is optional. If given, it should be a string that can be
+used as a machine-applicable suggestion to correct the warning. This is
+typically used when the identifier is renamed, but no other significant changes
+are necessary. When the `suggestion` field is used, you need to have
+`#![feature(deprecated_suggestion)]` at the crate root.
+
+Another difference from user code is that the `since` field is actually checked
+against the current version of `rustc`. If `since` is in a future version, then
+the `deprecated_in_future` lint is triggered which is default `allow`, but most
+of the standard library raises it to a warning with
+`#![warn(deprecated_in_future)]`.
+
+[blog]: https://www.ralfj.de/blog/2018/07/19/const.html
diff --git a/src/doc/rustc-dev-guide/src/stabilization_guide.md b/src/doc/rustc-dev-guide/src/stabilization_guide.md
new file mode 100644
index 000000000..454cd0f27
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/stabilization_guide.md
@@ -0,0 +1,210 @@
+# Request for stabilization
+
+**NOTE**: this page is about stabilizing language features.
+For stabilizing *library* features, see [Stabilizing a library feature].
+
+[Stabilizing a library feature]: ./stability.md#stabilizing-a-library-feature
+
+Once an unstable feature has been well-tested with no outstanding
+concern, anyone may push for its stabilization. It involves the
+following steps:
+
+<!-- toc -->
+
+## Documentation PRs
+
+<a name="updating-documentation"></a>
+
+If any documentation for this feature exists, it should be
+in the [`Unstable Book`], located at [`src/doc/unstable-book`].
+If it exists, the page for the feature gate should be removed.
+
+If there was documentation there, integrating it into the
+existing documentation is needed.
+
+If there wasn't documentation there, it needs to be added.
+
+Places that may need updated documentation:
+
+- [The Reference]: This must be updated, in full detail.
+- [The Book]: This may or may not need updating, depends.
+    If you're not sure, please open an issue on this repository
+    and it can be discussed.
+- standard library documentation: As needed. Language features
+    often don't need this, but if it's a feature that changes
+    how good examples are written, such as when `?` was added
+    to the language, updating examples is important.
+- [Rust by Example]: As needed.
+
+Prepare PRs to update documentation involving this new feature
+for repositories mentioned above. Maintainers of these repositories
+will keep these PRs open until the whole stabilization process
+has completed. Meanwhile, we can proceed to the next step.
+
+## Write a stabilization report
+
+Find the tracking issue of the feature, and create a short
+stabilization report. Essentially this would be a brief summary
+of the feature plus some links to test cases showing it works
+as expected, along with a list of edge cases that came up
+and were considered. This is a minimal "due diligence" that
+we do before stabilizing.
+
+The report should contain:
+
+- A summary, showing examples (e.g. code snippets) what is
+  enabled by this feature.
+- Links to test cases in our test suite regarding this feature
+  and describe the feature's behavior on encountering edge cases.
+- Links to the documentations (the PRs we have made in the
+  previous steps).
+- Any other relevant information.
+- The resolutions of any unresolved questions if the stabilization
+  is for an RFC.
+
+Examples of stabilization reports can be found in
+[rust-lang/rust#44494][report1] and [rust-lang/rust#28237][report2] (these links
+will bring you directly to the comment containing the stabilization report).
+
+[report1]: https://github.com/rust-lang/rust/issues/44494#issuecomment-360191474
+[report2]: https://github.com/rust-lang/rust/issues/28237#issuecomment-363374130
+
+## FCP
+
+If any member of the team responsible for tracking this
+feature agrees with stabilizing this feature, they will
+start the FCP (final-comment-period) process by commenting
+
+```text
+@rfcbot fcp merge
+```
+
+The rest of the team members will review the proposal. If the final
+decision is to stabilize, we proceed to do the actual code modification.
+
+## Stabilization PR
+
+*This is for stabilizing language features.  If you are stabilizing a library
+feature, see [the stabilization chapter of the std dev guide][std-guide-stabilization] instead.*
+
+Once we have decided to stabilize a feature, we need to have
+a PR that actually makes that stabilization happen. These kinds
+of PRs are a great way to get involved in Rust, as they take
+you on a little tour through the source code.
+
+Here is a general guide to how to stabilize a feature --
+every feature is different, of course, so some features may
+require steps beyond what this guide talks about.
+
+Note: Before we stabilize any feature, it's the rule that it
+should appear in the documentation.
+
+### Determining the stabilization version
+
+The version in which the feature will be stabilized *must* match
+the value of [the `src/version` file in `master`][src-version] when the PR is merged.
+
+It's worth checking [the version schedule on the Forge][forge-versions] to see whether
+changes are coming soon.  You'll usually use the version labelled "Nightly".
+"Nightly" is two versions higher than the current stable release,
+since what's currently in beta will be the next stable release,
+and any changes you're making now will be in the one after that.
+
+No PR is merged instantly, so you'll want to be careful around release time.
+The version bump happens [the Friday before][forge-release-process] the stable release,
+not the same time as the release.  So if you're opening a PR shortly before then,
+be prepared to update the version, or consider just opening it for one version
+higher than the current nightly, with a note saying not to merge until
+after the upcoming version bump.
+
+### Updating the feature-gate listing
+
+There is a central listing of feature-gates in
+[`compiler/rustc_feature`]. Search for the `declare_features!`
+macro. There should be an entry for the feature you are aiming
+to stabilize, something like (this example is taken from
+[rust-lang/rust#32409]:
+
+```rust,ignore
+// pub(restricted) visibilities (RFC 1422)
+(active, pub_restricted, "1.9.0", Some(32409)),
+```
+
+The above line should be moved down to the area for "accepted"
+features, declared below in a separate call to `declare_features!`.
+When it is done, it should look like:
+
+```rust,ignore
+// pub(restricted) visibilities (RFC 1422)
+(accepted, pub_restricted, "1.31.0", Some(32409)),
+// note that we changed this
+```
+
+(The version here is the one discussed in the previous section.)
+
+### Removing existing uses of the feature-gate
+
+Next search for the feature string (in this case, `pub_restricted`)
+in the codebase to find where it appears. Change uses of
+`#![feature(XXX)]` from the `std` and any rustc crates (this includes test folders
+under `library/` and `compiler/` but not the toplevel `test/` one) to be
+`#![cfg_attr(bootstrap, feature(XXX))]`. This includes the feature-gate
+only for stage0, which is built using the current beta (this is
+needed because the feature is still unstable in the current beta).
+
+Also, remove those strings from any tests. If there are tests
+specifically targeting the feature-gate (i.e., testing that the
+feature-gate is required to use the feature, but nothing else),
+simply remove the test.
+
+### Do not require the feature-gate to use the feature
+
+Most importantly, remove the code which flags an error if the
+feature-gate is not present (since the feature is now considered
+stable). If the feature can be detected because it employs some
+new syntax, then a common place for that code to be is in the
+same `compiler/rustc_ast_passes/src/feature_gate.rs`.
+For example, you might see code like this:
+
+```rust,ignore
+gate_feature_post!(&self, pub_restricted, span,
+ "`pub(restricted)` syntax is experimental");
+```
+
+This `gate_feature_post!` macro prints an error if the
+`pub_restricted` feature is not enabled. It is not needed
+now that `#[pub_restricted]` is stable.
+
+For more subtle features, you may find code like this:
+
+```rust,ignore
+if self.tcx.sess.features.borrow().pub_restricted { /* XXX */ }
+```
+
+This `pub_restricted` field (obviously named after the feature)
+would ordinarily be false if the feature flag is not present
+and true if it is. So transform the code to assume that the field
+is true. In this case, that would mean removing the `if` and
+leaving just the `/* XXX */`.
+
+```rust,ignore
+if self.tcx.sess.features.borrow().pub_restricted { /* XXX */ }
+becomes
+/* XXX */
+
+if self.tcx.sess.features.borrow().pub_restricted && something { /* XXX */ }
+ becomes
+if something { /* XXX */ }
+```
+
+[rust-lang/rust#32409]: https://github.com/rust-lang/rust/issues/32409
+[std-guide-stabilization]: https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html
+[src-version]: https://github.com/rust-lang/rust/blob/master/src/version
+[forge-versions]: https://forge.rust-lang.org/#current-release-versions
+[forge-release-process]: https://forge.rust-lang.org/release/process.html
+[`compiler/rustc_feature`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_feature/index.html
+[The Reference]: https://github.com/rust-lang/reference
+[The Book]: https://github.com/rust-lang/book
+[Rust by Example]: https://github.com/rust-lang/rust-by-example
+[`Unstable Book`]: https://doc.rust-lang.org/unstable-book/index.html
+[`src/doc/unstable-book`]: https://github.com/rust-lang/rust/tree/master/src/doc/unstable-book
diff --git a/src/doc/rustc-dev-guide/src/syntax-intro.md b/src/doc/rustc-dev-guide/src/syntax-intro.md
new file mode 100644
index 000000000..43ef44577
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/syntax-intro.md
@@ -0,0 +1,13 @@
+# Syntax and the AST
+
+Working directly with source code is very inconvenient and error-prone. Thus,
+before we do anything else, we convert raw source code into an AST. It turns
+out that doing even this involves a lot of work, including lexing, parsing,
+macro expansion, name resolution, conditional compilation, feature-gate
+checking, and validation of the AST. In this chapter, we take a look at all
+of these steps.
+
+Notably, there isn't always a clean ordering between these tasks. For example,
+macro expansion relies on name resolution to resolve the names of macros and
+imports. And parsing requires macro expansion, which in turn may require
+parsing the output of the macro.
diff --git a/src/doc/rustc-dev-guide/src/test-implementation.md b/src/doc/rustc-dev-guide/src/test-implementation.md
new file mode 100644
index 000000000..09a66cdc9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/test-implementation.md
@@ -0,0 +1,159 @@
+# The `#[test]` attribute
+
+<!-- toc -->
+
+Today, Rust programmers rely on a built in attribute called `#[test]`. All
+you have to do is mark a function as a test and include some asserts like so:
+
+```rust,ignore
+#[test]
+fn my_test() {
+    assert!(2+2 == 4);
+}
+```
+
+When this program is compiled using `rustc --test` or `cargo test`, it will
+produce an executable that can run this, and any other test function. This
+method of testing allows tests to live alongside code in an organic way. You
+can even put tests inside private modules:
+
+```rust,ignore
+mod my_priv_mod {
+    fn my_priv_func() -> bool {}
+
+    #[test]
+    fn test_priv_func() {
+        assert!(my_priv_func());
+    }
+}
+```
+
+Private items can thus be easily tested without worrying about how to expose
+them to any sort of external testing apparatus. This is key to the
+ergonomics of testing in Rust. Semantically, however, it's rather odd.
+How does any sort of `main` function invoke these tests if they're not visible?
+What exactly is `rustc --test` doing?
+
+`#[test]` is implemented as a syntactic transformation inside the compiler's
+[`rustc_ast` crate][rustc_ast]. Essentially, it's a fancy macro, that
+rewrites the crate in 3 steps:
+
+## Step 1: Re-Exporting
+
+As mentioned earlier, tests can exist inside private modules, so we need a
+way of exposing them to the main function, without breaking any existing
+code. To that end, `rustc_ast` will create local modules called
+`__test_reexports` that recursively reexport tests. This expansion translates
+the above example into:
+
+```rust,ignore
+mod my_priv_mod {
+    fn my_priv_func() -> bool {}
+
+    pub fn test_priv_func() {
+        assert!(my_priv_func());
+    }
+
+    pub mod __test_reexports {
+        pub use super::test_priv_func;
+    }
+}
+```
+
+Now, our test can be accessed as
+`my_priv_mod::__test_reexports::test_priv_func`. For deeper module
+structures, `__test_reexports` will reexport modules that contain tests, so a
+test at `a::b::my_test` becomes
+`a::__test_reexports::b::__test_reexports::my_test`. While this process seems
+pretty safe, what happens if there is an existing `__test_reexports` module?
+The answer: nothing.
+
+To explain, we need to understand [how the AST represents
+identifiers][Ident]. The name of every function, variable, module, etc. is
+not stored as a string, but rather as an opaque [Symbol][Symbol] which is
+essentially an ID number for each identifier. The compiler keeps a separate
+hashtable that allows us to recover the human-readable name of a Symbol when
+necessary (such as when printing a syntax error). When the compiler generates
+the `__test_reexports` module, it generates a new Symbol for the identifier,
+so while the compiler-generated `__test_reexports` may share a name with your
+hand-written one, it will not share a Symbol. This technique prevents name
+collision during code generation and is the foundation of Rust's macro
+hygiene.
+
+## Step 2: Harness Generation
+
+Now that our tests are accessible from the root of our crate, we need to do
+something with them. `rustc_ast` generates a module like so:
+
+```rust,ignore
+#[main]
+pub fn main() {
+    extern crate test;
+    test::test_main_static(&[&path::to::test1, /*...*/]);
+}
+```
+
+where `path::to::test1` is a constant of type `test::TestDescAndFn`.
+
+While this transformation is simple, it gives us a lot of insight into how
+tests are actually run. The tests are aggregated into an array and passed to
+a test runner called `test_main_static`. We'll come back to exactly what
+`TestDescAndFn` is, but for now, the key takeaway is that there is a crate
+called [`test`][test] that is part of Rust core, that implements all of the
+runtime for testing. `test`'s interface is unstable, so the only stable way
+to interact with it is through the `#[test]` macro.
+
+## Step 3: Test Object Generation
+
+If you've written tests in Rust before, you may be familiar with some of the
+optional attributes available on test functions. For example, a test can be
+annotated with `#[should_panic]` if we expect the test to cause a panic. It
+looks something like this:
+
+```rust,ignore
+#[test]
+#[should_panic]
+fn foo() {
+    panic!("intentional");
+}
+```
+
+This means our tests are more than just simple functions, they have
+configuration information as well. `test` encodes this configuration data
+into a struct called [`TestDesc`][TestDesc]. For each test function in a
+crate, `rustc_ast` will parse its attributes and generate a `TestDesc`
+instance. It then combines the `TestDesc` and test function into the
+predictably named `TestDescAndFn` struct, that `test_main_static` operates
+on. For a given test, the generated `TestDescAndFn` instance looks like so:
+
+```rust,ignore
+self::test::TestDescAndFn{
+  desc: self::test::TestDesc{
+    name: self::test::StaticTestName("foo"),
+    ignore: false,
+    should_panic: self::test::ShouldPanic::Yes,
+    allow_fail: false,
+  },
+  testfn: self::test::StaticTestFn(||
+    self::test::assert_test_result(::crate::__test_reexports::foo())),
+}
+```
+
+Once we've constructed an array of these test objects, they're passed to the
+test runner via the harness generated in step 2.
+
+## Inspecting the generated code
+
+On nightly rust, there's an unstable flag called `unpretty` that you can use
+to print out the module source after macro expansion:
+
+```bash
+$ rustc my_mod.rs -Z unpretty=hir
+```
+
+[test]: https://doc.rust-lang.org/test/index.html
+[TestDesc]: https://doc.rust-lang.org/test/struct.TestDesc.html
+[Symbol]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Symbol.html
+[Ident]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/symbol/struct.Ident.html
+[eRFC]: https://github.com/rust-lang/rfcs/blob/master/text/2318-custom-test-frameworks.md
+[rustc_ast]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_ast
diff --git a/src/doc/rustc-dev-guide/src/tests/adding.md b/src/doc/rustc-dev-guide/src/tests/adding.md
new file mode 100644
index 000000000..2fb1e0b65
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/adding.md
@@ -0,0 +1,195 @@
+# Adding new tests
+
+<!-- toc -->
+
+**In general, we expect every PR that fixes a bug in rustc to come
+accompanied by a regression test of some kind.** This test should fail
+in master but pass after the PR. These tests are really useful for
+preventing us from repeating the mistakes of the past.
+
+The first thing to decide is which kind of test to add.
+This will depend on the nature of the change and what you want to exercise.
+Here are some rough guidelines:
+
+- The majority of compiler tests are done with [compiletest].
+  - The majority of compiletest tests are [UI](ui.md) tests in the [`src/test/ui`] directory.
+- Changes to the standard library are usually tested within the standard library itself.
+  - The majority of standard library tests are written as doctests,
+    which illustrate and exercise typical API behavior.
+  - Additional [unit tests](intro.md#package-tests) should go in
+    `library/${crate}/tests` (where `${crate}` is usually `core`, `alloc`, or `std`).
+- If the code is part of an isolated system, and you are not testing compiler output,
+  consider using a [unit or integration test](intro.md#package-tests).
+- Need to run rustdoc? Prefer a `rustdoc` or `rustdoc-ui` test.
+  Occasionally you'll need `rustdoc-js` as well.
+- Other compiletest test suites are generally used for special purposes:
+  - Need to run gdb or lldb? Use the `debuginfo` test suite.
+  - Need to inspect LLVM IR or MIR IR? Use the `codegen` or `mir-opt` test suites.
+  - Need to inspect the resulting binary in some way?
+    Then use `run-make`.
+  - Check out the [compiletest] chapter for more specialized test suites.
+
+[compiletest]: compiletest.md
+[`src/test/ui`]: https://github.com/rust-lang/rust/tree/master/src/test/ui/
+
+## UI test walkthrough
+
+The following is a basic guide for creating a [UI test](ui.md), which is one
+of the most common compiler tests.
+For this tutorial, we'll be adding a test for an async error message.
+
+### Step 1. Add a test file
+
+The first step is to create a Rust source file somewhere in the
+[`src/test/ui`] tree.
+When creating a test, do your best to find a good location and name (see [Test
+organization](ui.md#test-organization) for more).
+Since naming is the hardest part of development, everything should be downhill
+from here!
+
+Let's place our async test at `src/test/ui/async-await/await-without-async.rs`:
+
+```rust,ignore
+// Check what happens when using await in a non-async fn.
+// edition:2018
+
+async fn foo() {}
+
+fn bar() {
+    foo().await
+}
+
+fn main() {}
+```
+
+A few things to notice about our test:
+
+* The top should start with a short comment that [explains what the test is
+  for](#explanatory_comment).
+* The `// edition:2018` comment is called a [header](headers.md) which provides
+  instructions to compiletest on how to build the test.
+  Here we need to set the edition for `async` to work (the default is 2015).
+* Following that is the source of the test.
+  Try to keep it succinct and to the point.
+  This may require some effort if you are trying to minimize an example from a
+  bug report.
+* We end this test with an empty `fn main` function.
+  This is because the default for UI tests is a `bin` crate-type,
+  and we don't want the "main not found" error in our test.
+  Alternatively, you could add `#![crate_type="lib"]`.
+
+### Step 2. Generate the expected output
+
+The next step is to create the expected output from the compiler.
+This can be done with the `--bless` option:
+
+```sh
+./x.py test src/test/ui/async-await/await-without-async.rs --bless
+```
+
+This will build the compiler (if it hasn't already been built), compile the
+test, and place the output of the compiler in a file called
+`src/test/ui/async-await/await-without-async.stderr`.
+
+However, this step will fail!
+You should see an error message, something like this:
+
+> error: /rust/src/test/ui/async-await/await-without-async.rs:7: unexpected
+> error: '7:10: 7:16: `await` is only allowed inside `async` functions and
+> blocks [E0728]'
+
+### Step 3. Add error annotations
+
+Every error needs to be annotated with a comment in the source with the text
+of the error.
+In this case, we can add the following comment to our test file:
+
+```rust,ignore
+fn bar() {
+    foo().await
+//~^ ERROR `await` is only allowed inside `async` functions and blocks
+}
+```
+
+The `//~^` squiggle caret comment tells compiletest that the error belongs to
+the previous line (more on this in the [Error
+annotations](ui.md#error-annotations) section).
+
+Save that, and run the test again:
+
+```sh
+./x.py test src/test/ui/async-await/await-without-async.rs
+```
+
+It should now pass, yay!
+
+### Step 4. Review the output
+
+Somewhat hand-in-hand with the previous step, you should inspect the `.stderr`
+file that was created to see if it looks like how you expect.
+If you are adding a new diagnostic message, now would be a good time to
+also consider how readable the message looks overall, particularly for
+people new to Rust.
+
+Our example `src/test/ui/async-await/await-without-async.stderr` file should
+look like this:
+
+```text
+error[E0728]: `await` is only allowed inside `async` functions and blocks
+  --> $DIR/await-without-async.rs:7:10
+   |
+LL | fn bar() {
+   |    --- this is not `async`
+LL |     foo().await
+   |          ^^^^^^ only allowed inside `async` functions and blocks
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0728`.
+```
+
+You may notice some things look a little different than the regular
+compiler output.
+The `$DIR` removes the path information which will differ between systems.
+The `LL` values replace the line numbers.
+That helps avoid small changes in the source from triggering large diffs.
+See the [Normalization](ui.md#normalization) section for more.
+
+Around this stage, you may need to iterate over the last few steps a few times
+to tweak your test, re-bless the test, and re-review the output.
+
+### Step 5. Check other tests
+
+Sometimes when adding or changing a diagnostic message, this will affect
+other tests in the test suite.
+The final step before posting a PR is to check if you have affected anything else.
+Running the UI suite is usually a good start:
+
+```sh
+./x.py test src/test/ui
+```
+
+If other tests start failing, you may need to investigate what has changed
+and if the new output makes sense.
+You may also need to re-bless the output with the `--bless` flag.
+
+<a name="explanatory_comment"></a>
+
+## Comment explaining what the test is about
+
+The first comment of a test file should **summarize the point
+of the test**, and highlight what is important about it.
+If there is an issue number associated with the test, include
+the issue number.
+
+This comment doesn't have to be super extensive. Just something like
+"Regression test for #18060: match arms were matching in the wrong
+order."  might already be enough.
+
+These comments are very useful to others later on when your test
+breaks, since they often can highlight what the problem is. They are
+also useful if for some reason the tests need to be refactored, since
+they let others know which parts of the test were important (often a
+test must be rewritten because it no longer tests what is was meant to
+test, and then it's useful to know what it *was* meant to test
+exactly).
diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
new file mode 100644
index 000000000..21f834130
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -0,0 +1,73 @@
+# Testing with CI
+
+## Testing infrastructure
+
+When a Pull Request is opened on GitHub, [GitHub Actions] will automatically
+launch a build that will run all tests on some configurations
+(x86_64-gnu-llvm-12 linux. x86_64-gnu-tools linux, mingw-check linux).
+In essence, each runs `./x.py test` with various different options.
+
+The integration bot [bors] is used for coordinating merges to the master branch.
+When a PR is approved, it goes into a [queue] where merges are tested one at a
+time on a wide set of platforms using GitHub Actions. Due to the limit on the
+number of parallel jobs, we run CI under the [rust-lang-ci] organization except
+for PRs.
+Most platforms only run the build steps, some run a restricted set of tests,
+only a subset run the full suite of tests (see Rust's [platform tiers]).
+
+If everything passes, then all of the distribution artifacts that were
+generated during the CI run are published.
+
+[GitHub Actions]: https://github.com/rust-lang/rust/actions
+[rust-lang-ci]: https://github.com/rust-lang-ci/rust/actions
+[bors]: https://github.com/servo/homu
+[queue]: https://bors.rust-lang.org/queue/rust
+[platform tiers]: https://forge.rust-lang.org/release/platform-support.html#rust-platform-support
+
+## Using CI to test
+
+In some cases, a PR may run into problems with running tests on a particular
+platform or configuration.
+If you can't run those tests locally, don't hesitate to use CI resources to
+try out a fix.
+
+As mentioned above, opening or updating a PR will only run on a small subset
+of configurations.
+Only when a PR is approved will it go through the full set of test configurations.
+However, you can try one of those configurations in your PR before it is approved.
+For example, if a Windows build fails, but you don't have access to a Windows
+machine, you can try running the Windows job that failed on CI within your PR
+after pushing a possible fix.
+
+To do this, you'll need to edit [`src/ci/github-actions/ci.yml`].
+The `jobs` section defines the jobs that will run.
+The `jobs.pr` section defines everything that will run in a push to a PR.
+The `jobs.auto` section defines the full set of tests that are run after a PR is approved.
+You can copy one of the definitions from the `auto` section up to the `pr` section.
+
+For example, the `x86_64-msvc-1` and `x86_64-msvc-2` jobs are responsible for
+running the 64-bit MSVC tests.
+You can copy those up to the `jobs.pr.strategy.matrix.include` section with
+the other jobs.
+
+The comment at the top of `ci.yml` will tell you to run this command:
+
+```sh
+./x.py run src/tools/expand-yaml-anchors
+````
+
+This will generate the true [`.github/workflows/ci.yml`] which is what GitHub
+Actions uses.
+
+Then, you can commit those two files and push to GitHub.
+GitHub Actions should launch the tests.
+
+After you have finished, don't forget to remove any changes you have made to `ci.yml`.
+
+Although you are welcome to use CI, just be conscientious that this is a shared
+resource with limited concurrency.
+Try not to enable too many jobs at once (one or two should be sufficient in
+most cases).
+
+[`src/ci/github-actions/ci.yml`]: https://github.com/rust-lang/rust/blob/master/src/ci/github-actions/ci.yml
+[`.github/workflows/ci.yml`]: https://github.com/rust-lang/rust/blob/master/.github/workflows/ci.yml#L1
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
new file mode 100644
index 000000000..5c3dcf54b
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -0,0 +1,526 @@
+# Compiletest
+
+<!-- toc -->
+
+## Introduction
+
+`compiletest` is the main test harness of the Rust test suite.
+It allows test authors to organize large numbers of tests
+(the Rust compiler has many thousands),
+efficient test execution (parallel execution is supported),
+and allows the test author to configure behavior and expected results of both
+individual and groups of tests.
+
+`compiletest` may check test code for success, for runtime failure,
+or for compile-time failure.
+Tests are typically organized as a Rust source file with annotations in
+comments before and/or within the test code.
+These comments serve to direct `compiletest` on if or how to run the test,
+what behavior to expect, and more.
+See [header commands](headers.md) and the test suite documentation below
+for more details on these annotations.
+
+See the [Adding new tests](adding.md) chapter for a tutorial on creating a new
+test, and the [Running tests](running.md) chapter on how to run the test
+suite.
+
+## Test suites
+
+All of the tests are in the [`src/test`] directory.
+The tests are organized into "suites", with each suite in a separate subdirectory.
+Each test suite behaves a little differently, with different compiler behavior
+and different checks for correctness.
+For example, the [`src/test/incremental`] directory contains tests for
+incremental compilation.
+The various suites are defined in [`src/tools/compiletest/src/common.rs`] in
+the `pub enum Mode` declaration.
+
+The following test suites are available, with links for more information:
+
+- [`ui`](ui.md) — tests that check the stdout/stderr from the compilation
+  and/or running the resulting executable
+- `ui-fulldeps` — `ui` tests which require a linkable build of `rustc` (such
+  as using `extern crate rustc_span;` or used as a plugin)
+- [`pretty`](#pretty-printer-tests) — tests for pretty printing
+- [`incremental`](#incremental-tests) — tests incremental compilation behavior
+- [`debuginfo`](#debuginfo-tests) — tests for debuginfo generation running debuggers
+- [`codegen`](#codegen-tests) — tests for code generation
+- [`codegen-units`](#codegen-units-tests) — tests for codegen unit partitioning
+- [`assembly`](#assembly-tests) — verifies assembly output
+- [`mir-opt`](#mir-opt-tests) — tests for MIR generation
+- [`run-make`](#run-make-tests) — general purpose tests using a Makefile
+- `run-make-fulldeps` — `run-make` tests which require a linkable build of `rustc`,
+  or the rust demangler
+- [`run-pass-valgrind`](#valgrind-tests) — tests run with Valgrind
+- [Rustdoc tests](../rustdoc.md#tests):
+    - `rustdoc` — tests for rustdoc, making sure that the generated files
+      contain the expected documentation.
+    - `rustdoc-gui` — tests for rustdoc's GUI using a web browser.
+    - `rustdoc-js` — tests to ensure the rustdoc search is working as expected.
+    - `rustdoc-js-std` — tests to ensure the rustdoc search is working as expected
+      (run specifically on the std docs).
+    - `rustdoc-json` — tests on the JSON output of rustdoc.
+    - `rustdoc-ui` — tests on the terminal output of rustdoc.
+
+[`src/test`]: https://github.com/rust-lang/rust/blob/master/src/test
+[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/common.rs
+
+### Pretty-printer tests
+
+The tests in [`src/test/pretty`] exercise the "pretty-printing" functionality of `rustc`.
+The `-Z unpretty` CLI option for `rustc` causes it to translate the input source
+into various different formats, such as the Rust source after macro expansion.
+
+The pretty-printer tests have several [header commands](headers.md) described below.
+These commands can significantly change the behavior of the test, but the
+default behavior without any commands is to:
+
+1. Run `rustc -Zunpretty=normal` on the source file
+2. Run `rustc -Zunpretty=normal` on the output of the previous step
+3. The output of the previous two steps should be the same.
+4. Run `rustc -Zno-codegen` on the output to make sure that it can type check
+   (this is similar to running `cargo check`)
+
+If any of the commands above fail, then the test fails.
+
+The header commands for pretty-printing tests are:
+
+* `pretty-mode` specifies the mode pretty-print tests should run in
+  (that is, the argument to `-Zunpretty`).
+  The default is `normal` if not specified.
+* `pretty-compare-only` causes a pretty test to only compare the pretty-printed output
+  (stopping after step 3 from above).
+  It will not try to compile the expanded output to type check it.
+  This is needed for a pretty-mode that does not expand to valid
+  Rust, or for other situations where the expanded output cannot be compiled.
+* `pretty-expanded` allows a pretty test to also check that the expanded
+  output can be type checked.
+  That is, after the steps above, it does two more steps:
+
+  > 5. Run `rustc -Zunpretty=expanded` on the original source
+  > 6. Run `rustc -Zno-codegen` on the expanded output to make sure that it can type check
+
+  This is needed because not all code can be compiled after being expanded.
+  Pretty tests should specify this if they can.
+  An example where this cannot be used is if the test includes `println!`.
+  That macro expands to reference private internal functions of the standard
+  library that cannot be called directly without the `fmt_internals` feature
+  gate.
+
+  More history about this may be found in
+  [#23616](https://github.com/rust-lang/rust/issues/23616#issuecomment-484999901).
+* `pp-exact` is used to ensure a pretty-print test results in specific output.
+  If specified without a value, then it means the pretty-print output should
+  match the original source.
+  If specified with a value, as in `// pp-exact:foo.pp`,
+  it will ensure that the pretty-printed output matches the contents of the given file.
+  Otherwise, if `pp-exact` is not specified, then the pretty-printed output
+  will be pretty-printed one more time, and the output of the two
+  pretty-printing rounds will be compared to ensure that the pretty-printed
+  output converges to a steady state.
+
+[`src/test/pretty`]: https://github.com/rust-lang/rust/tree/master/src/test/pretty
+
+### Incremental tests
+
+The tests in [`src/test/incremental`] exercise incremental compilation.
+They use [revision headers](#revisions) to tell compiletest to run the
+compiler in a series of steps.
+Compiletest starts with an empty directory with the `-C incremental` flag, and
+then runs the compiler for each revision, reusing the incremental results from
+previous steps.
+The revisions should start with:
+
+* `rpass` — the test should compile and run successfully
+* `rfail` — the test should compile successfully, but the executable should fail to run
+* `cfail` — the test should fail to compile
+
+To make the revisions unique, you should add a suffix like `rpass1` and `rpass2`.
+
+To simulate changing the source, compiletest also passes a `--cfg` flag with
+the current revision name.
+For example, this will run twice, simulating changing a function:
+
+```rust,ignore
+// revisions: rpass1 rpass2
+
+#[cfg(rpass1)]
+fn foo() {
+    println!("one");
+}
+
+#[cfg(rpass2)]
+fn foo() {
+    println!("two");
+}
+
+fn main() { foo(); }
+```
+
+`cfail` tests support the `forbid-output` header to specify that a certain
+substring must not appear anywhere in the compiler output.
+This can be useful to ensure certain errors do not appear, but this can be
+fragile as error messages change over time, and a test may no longer be
+checking the right thing but will still pass.
+
+`cfail` tests support the `should-ice` header to specify that a test should
+cause an Internal Compiler Error (ICE).
+This is a highly specialized header to check that the incremental cache
+continues to work after an ICE.
+
+[`src/test/incremental`]: https://github.com/rust-lang/rust/tree/master/src/test/incremental
+
+
+### Debuginfo tests
+
+The tests in [`src/test/debuginfo`] test debuginfo generation.
+They build a program, launch a debugger, and issue commands to the debugger.
+A single test can work with cdb, gdb, and lldb.
+
+Most tests should have the `// compile-flags: -g` header or something similar
+to generate the appropriate debuginfo.
+
+To set a breakpoint on a line, add a `// #break` comment on the line.
+
+The debuginfo tests consist of a series of debugger commands along with
+"check" lines which specify output that is expected from the debugger.
+
+The commands are comments of the form `// $DEBUGGER-command:$COMMAND` where
+`$DEBUGGER` is the debugger being used and `$COMMAND` is the debugger command
+to execute.
+The debugger values can be:
+
+* `cdb`
+* `gdb`
+* `gdbg` — GDB without Rust support (versions older than 7.11)
+* `gdbr` — GDB with Rust support
+* `lldb`
+* `lldbg` — LLDB without Rust support
+* `lldbr` — LLDB with Rust support (this no longer exists)
+
+The command to check the output are of the form `// $DEBUGGER-check:$OUTPUT`
+where `$OUTPUT` is the output to expect.
+
+For example, the following will build the test, start the debugger, set a
+breakpoint, launch the program, inspect a value, and check what the debugger
+prints:
+
+```rust,ignore
+// compile-flags: -g
+
+// lldb-command: run
+// lldb-command: print foo
+// lldb-check: $0 = 123
+
+fn main() {
+    let foo = 123;
+    b(); // #break
+}
+
+fn b() {}
+```
+
+The following [header commands](headers.md) are available to disable a
+test based on the debugger currently being used:
+
+* `min-cdb-version: 10.0.18317.1001` — ignores the test if the version of cdb
+  is below the given version
+* `min-gdb-version: 8.2` — ignores the test if the version of gdb is below the
+  given version
+* `ignore-gdb-version: 9.2` — ignores the test if the version of gdb is equal
+  to the given version
+* `ignore-gdb-version: 7.11.90 - 8.0.9` — ignores the test if the version of
+  gdb is in a range (inclusive)
+* `min-lldb-version: 310` — ignores the test if the version of lldb is below
+  the given version
+* `rust-lldb` — ignores the test if lldb is not contain the Rust plugin.
+  NOTE: The "Rust" version of LLDB doesn't exist anymore, so this will always be ignored.
+  This should probably be removed.
+
+[`src/test/debuginfo`]: https://github.com/rust-lang/rust/tree/master/src/test/debuginfo
+
+
+### Codegen tests
+
+The tests in [`src/test/codegen`] test LLVM code generation.
+They compile the test with the `--emit=llvm-ir` flag to emit LLVM IR.
+They then run the LLVM [FileCheck] tool.
+The test is annotated with various `// CHECK` comments to check the generated code.
+See the FileCheck documentation for a tutorial and more information.
+
+See also the [assembly tests](#assembly-tests) for a similar set of tests.
+
+[`src/test/codegen`]: https://github.com/rust-lang/rust/tree/master/src/test/codegen
+[FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
+
+
+### Assembly tests
+
+The tests in [`src/test/assembly`] test LLVM assembly output.
+They compile the test with the `--emit=asm` flag to emit a `.s` file with the
+assembly output.
+They then run the LLVM [FileCheck] tool.
+
+Each test should be annotated with the `// assembly-output:` header
+with a value of either `emit-asm` or `ptx-linker` to indicate
+the type of assembly output.
+
+Then, they should be annotated with various `// CHECK` comments to check the
+assembly output.
+See the FileCheck documentation for a tutorial and more information.
+
+See also the [codegen tests](#codegen-tests) for a similar set of tests.
+
+[`src/test/assembly`]: https://github.com/rust-lang/rust/tree/master/src/test/assembly
+
+
+### Codegen-units tests
+
+The tests in [`src/test/codegen-units`] test the
+[monomorphization](../backend/monomorph.md) collector and CGU partitioning.
+
+These tests work by running `rustc` with a flag to print the result of the
+monomorphization collection pass, and then special annotations in the file are
+used to compare against that.
+
+Each test should be annotated with the `// compile-flags:-Zprint-mono-items=VAL`
+header with the appropriate VAL to instruct `rustc` to print the
+monomorphization information.
+
+Then, the test should be annotated with comments of the form `//~ MONO_ITEM name`
+where `name` is the monomorphized string printed by rustc like `fn <u32 as Trait>::foo`.
+
+To check for CGU partitioning, a comment of the form `//~ MONO_ITEM name @@ cgu`
+where `cgu` is a space separated list of the CGU names and the linkage
+information in brackets.
+For example: `//~ MONO_ITEM static function::FOO @@ statics[Internal]`
+
+[`src/test/codegen-units`]: https://github.com/rust-lang/rust/tree/master/src/test/codegen-units
+
+
+### Mir-opt tests
+
+The tests in [`src/test/mir-opt`] check parts of the generated MIR to make
+sure it is generated correctly and is doing the expected optimizations.
+Check out the [MIR Optimizations](../mir/optimizations.md) chapter for more.
+
+Compiletest will build the test with several flags to dump the MIR output and
+set a baseline for optimizations:
+
+* `-Copt-level=1`
+* `-Zdump-mir=all`
+* `-Zmir-opt-level=4`
+* `-Zvalidate-mir`
+* `-Zdump-mir-exclude-pass-number`
+
+The test should be annotated with `// EMIT_MIR` comments that specify files that
+will contain the expected MIR output.
+You can use `x.py test --bless` to create the initial expected files.
+
+There are several forms the `EMIT_MIR` comment can take:
+
+* `// EMIT_MIR $MIR_PATH.mir` — This will check that the given filename
+  matches the exact output from the MIR dump.
+  For example, `my_test.main.SimplifyCfg-elaborate-drops.after.mir` will load
+  that file from the test directory, and compare it against the dump from
+  rustc.
+
+  Checking the "after" file (which is after optimization) is useful if you are
+  interested in the final state after an optimization.
+  Some rare cases may want to use the "before" file for completeness.
+
+* `// EMIT_MIR $MIR_PATH.diff` — where `$MIR_PATH` is the filename of the MIR
+  dump, such as `my_test_name.my_function.EarlyOtherwiseBranch`.
+  Compiletest will diff the `.before.mir` and `.after.mir` files, and compare
+  the diff output to the expected `.diff` file from the `EMIT_MIR` comment.
+
+  This is useful if you want to see how an optimization changes the MIR.
+
+* `// EMIT_MIR $MIR_PATH.dot` or `$MIR_PATH.html` — These are special cases
+  for other MIR outputs (via `-Z dump-mir-graphviz` and `-Z dump-mir-spanview`)
+  that will check that the output matches the given file.
+
+By default 32 bit and 64 bit targets use the same dump files, which can be
+problematic in the presence of pointers in constants or other bit width
+dependent things. In that case you can add `// EMIT_MIR_FOR_EACH_BIT_WIDTH` to
+your test, causing separate files to be generated for 32bit and 64bit systems.
+
+[`src/test/mir-opt`]: https://github.com/rust-lang/rust/tree/master/src/test/mir-opt
+
+
+### Run-make tests
+
+The tests in [`src/test/run-make`] are general-purpose tests using Makefiles
+which provide the ultimate in flexibility.
+These should be used as a last resort.
+If possible, you should use one of the other test suites.
+If there is some minor feature missing which you need for your test,
+consider extending compiletest to add a header command for what you need.
+However, sometimes just running a bunch of commands is really what you
+need, `run-make` is here to the rescue!
+
+Each test should be in a separate directory with a `Makefile` indicating the
+commands to run.
+There is a [`tools.mk`] Makefile which you can include which provides a bunch of
+utilities to make it easier to run commands and compare outputs.
+Take a look at some of the other tests for some examples on how to get started.
+
+[`tools.mk`]: https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/tools.mk
+[`src/test/run-make`]: https://github.com/rust-lang/rust/tree/master/src/test/run-make
+
+
+### Valgrind tests
+
+The tests in [`src/test/run-pass-valgrind`] are for use with [Valgrind].
+These are currently vestigial, as Valgrind is no longer used in CI.
+These may be removed in the future.
+
+[Valgrind]: https://valgrind.org/
+[`src/test/run-pass-valgrind`]: https://github.com/rust-lang/rust/tree/master/src/test/run-pass-valgrind
+
+
+## Building auxiliary crates
+
+It is common that some tests require additional auxiliary crates to be compiled.
+There are two [headers](headers.md) to assist with that:
+
+* `aux-build`
+* `aux-crate`
+
+`aux-build` will build a separate crate from the named source file.
+The source file should be in a directory called `auxiliary` beside the test file.
+
+```rust,ignore
+// aux-build: my-helper.rs
+
+extern crate my_helper;
+// ... You can use my_helper.
+```
+
+The aux crate will be built as a dylib if possible (unless on a platform that
+does not support them, or the `no-prefer-dynamic` header is specified in the
+aux file).
+The `-L` flag is used to find the extern crates.
+
+`aux-crate` is very similar to `aux-build`; however, it uses the `--extern`
+flag to link to the extern crate.
+That allows you to specify the additional syntax of the `--extern` flag, such
+as renaming a dependency.
+For example, `// aux-crate:foo=bar.rs` will compile `auxiliary/bar.rs` and
+make it available under then name `foo` within the test.
+This is similar to how Cargo does dependency renaming.
+
+### Auxiliary proc-macro
+
+If you want a proc-macro dependency, then there currently is some ceremony
+needed.
+Place the proc-macro itself in a file like `auxiliary/my-proc-macro.rs`
+with the following structure:
+
+```rust,ignore
+// force-host
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn foo(input: TokenStream) -> TokenStream {
+    "".parse().unwrap()
+}
+```
+
+The `force-host` is needed because proc-macros are loaded in the host
+compiler, and `no-prefer-dynamic` is needed to tell compiletest to not use
+`prefer-dynamic` which is not compatible with proc-macros.
+The `#![crate_type]` attribute is needed to specify the correct crate-type.
+
+Then in your test, you can build with with `aux-build`:
+
+```rust,ignore
+// aux-build: my-proc-macro.rs
+
+extern crate my_proc_macro;
+
+fn main() {
+    my_proc_macro::foo!();
+}
+```
+
+
+## Revisions
+
+Certain classes of tests support "revisions" (as of <!-- date: 2022-07 --> July 2022,
+this includes UI, assembly, codegen, debuginfo, incremental, and rustdoc UI tests,
+though incremental tests are somewhat different).
+Revisions allow a single test file to be used for multiple tests.
+This is done by adding a special header at the top of the file:
+
+```rust,ignore
+// revisions: foo bar baz
+```
+
+This will result in the test being compiled (and tested) three times,
+once with `--cfg foo`, once with `--cfg bar`, and once with `--cfg
+baz`.
+You can therefore use `#[cfg(foo)]` etc within the test to tweak
+each of these results.
+
+You can also customize headers and expected error messages to a particular
+revision. To do this, add `[foo]` (or `bar`, `baz`, etc) after the `//`
+comment, like so:
+
+```rust,ignore
+// A flag to pass in only for cfg `foo`:
+//[foo]compile-flags: -Z verbose
+
+#[cfg(foo)]
+fn test_foo() {
+    let x: usize = 32_u32; //[foo]~ ERROR mismatched types
+}
+```
+
+Note that not all headers have meaning when customized to a revision.
+For example, the `ignore-test` header (and all "ignore" headers)
+currently only apply to the test as a whole, not to particular
+revisions. The only headers that are intended to really work when
+customized to a revision are error patterns and compiler flags.
+
+
+## Compare modes
+
+Compiletest can be run in different modes, called *compare modes*, which can
+be used to compare the behavior of all tests with different compiler flags
+enabled.
+This can help highlight what differences might appear with certain flags, and
+check for any problems that might arise.
+
+To run the tests in a different mode, you need to pass the `--compare-mode`
+CLI flag:
+
+```bash
+./x.py test src/test/ui --compare-mode=chalk
+```
+
+The possible compare modes are:
+
+* `polonius` — Runs with Polonius with `-Zpolonius`.
+* `chalk` — Runs with Chalk with `-Zchalk`.
+* `split-dwarf` — Runs with unpacked split-DWARF with `-Csplit-debuginfo=unpacked`.
+* `split-dwarf-single` — Runs with packed split-DWARF with `-Csplit-debuginfo=packed`.
+
+See [UI compare modes](ui.md#compare-modes) for more information about how UI
+tests support different output for different modes.
+
+In CI, compare modes are only used in one Linux builder, and only with the
+following settings:
+
+* `src/test/debuginfo`: Uses `split-dwarf` mode.
+  This helps ensure that none of the debuginfo tests are affected when
+  enabling split-DWARF.
+
+Note that compare modes are separate to [revisions](#revisions).
+All revisions are tested when running `./x.py test src/test/ui`, however
+compare-modes must be manually run individually via the `--compare-mode` flag.
diff --git a/src/doc/rustc-dev-guide/src/tests/crater.md b/src/doc/rustc-dev-guide/src/tests/crater.md
new file mode 100644
index 000000000..9a7ff3871
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/crater.md
@@ -0,0 +1,45 @@
+# Crater
+
+[Crater](https://github.com/rust-lang/crater) is a tool for compiling
+and running tests for _every_ crate on [crates.io](https://crates.io) (and a
+few on GitHub). It is mainly used for checking the extent of breakage when
+implementing potentially breaking changes and ensuring lack of breakage by
+running beta vs stable compiler versions.
+
+## When to run Crater
+
+You should request a crater run if your PR makes large changes to the compiler
+or could cause breakage. If you are unsure, feel free to ask your PR's reviewer.
+
+## Requesting Crater Runs
+
+The rust team maintains a few machines that can be used for running crater runs
+on the changes introduced by a PR. If your PR needs a crater run, leave a
+comment for the triage team in the PR thread. Please inform the team whether
+you require a "check-only" crater run, a "build only" crater run, or a
+"build-and-test" crater run. The difference is primarily in time; the
+conservative (if you're not sure) option is to go for the build-and-test run.
+If making changes that will only have an effect at compile-time (e.g.,
+implementing a new trait) then you only need a check run.
+
+Your PR will be enqueued by the triage team and the results will be posted when
+they are ready. Check runs will take around ~3-4 days, with the other two
+taking 5-6 days on average.
+
+While crater is really useful, it is also important to be aware of a few
+caveats:
+
+- Not all code is on crates.io! There is a lot of code in repos on GitHub and
+  elsewhere. Also, companies may not wish to publish their code. Thus, a
+  successful crater run is not a magically green light that there will be no
+  breakage; you still need to be careful.
+
+- Crater only runs Linux builds on x86_64. Thus, other architectures and
+  platforms are not tested. Critically, this includes Windows.
+
+- Many crates are not tested. This could be for a lot of reasons, including
+  that the crate doesn't compile any more (e.g. used old nightly features),
+  has broken or flaky tests, requires network access, or other reasons.
+
+- Before crater can be run, `@bors try` needs to succeed in building artifacts.
+  This means that if your code doesn't compile, you cannot run crater.
diff --git a/src/doc/rustc-dev-guide/src/tests/docker.md b/src/doc/rustc-dev-guide/src/tests/docker.md
new file mode 100644
index 000000000..feb614c51
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/docker.md
@@ -0,0 +1,52 @@
+# Testing with Docker
+
+The Rust tree includes [Docker] image definitions for the platforms used on
+GitHub Actions in [`src/ci/docker`].
+The script [`src/ci/docker/run.sh`] is used to build the Docker image, run it,
+build Rust within the image, and run the tests.
+
+You can run these images on your local development machine. This can be
+helpful to test environments different from your local system. First you will
+need to install Docker on a Linux, Windows, or macOS system (typically Linux
+will be much faster than Windows or macOS because the latter use virtual
+machines to emulate a Linux environment). To enter interactive mode which will
+start a bash shell in the container, run `src/ci/docker/run.sh --dev <IMAGE>`
+where `<IMAGE>` is one of the directory names in `src/ci/docker` (for example
+`x86_64-gnu` is a fairly standard Ubuntu environment).
+
+The docker script will mount your local Rust source tree in read-only mode,
+and an `obj` directory in read-write mode. All of the compiler artifacts will
+be stored in the `obj` directory. The shell will start out in the `obj`
+directory. From there, you can run `../src/ci/run.sh` which will run the build
+as defined by the image.
+
+Alternatively, you can run individual commands to do specific tasks. For
+example, you can run `python3 ../x.py test src/test/ui` to just run UI tests.
+Note that there is some configuration in the [`src/ci/run.sh`] script that you
+may need to recreate. Particularly, set `submodules = false` in your
+`config.toml` so that it doesn't attempt to modify the read-only directory.
+
+Some additional notes about using the Docker images:
+
+- Some of the std tests require IPv6 support. Docker on Linux seems to have it
+  disabled by default. Run the commands in [`enable-docker-ipv6.sh`] to enable
+  IPv6 before creating the container. This only needs to be done once.
+- The container will be deleted automatically when you exit the shell, however
+  the build artifacts persist in the `obj` directory. If you are switching
+  between different Docker images, the artifacts from previous environments
+  stored in the `obj` directory may confuse the build system. Sometimes you
+  will need to delete parts or all of the `obj` directory before building
+  inside the container.
+- The container is bare-bones, with only a minimal set of packages. You may
+  want to install some things like `apt install less vim`.
+- You can open multiple shells in the container. First you need the container
+  name (a short hash), which is displayed in the shell prompt, or you can run
+  `docker container ls` outside of the container to list the available
+  containers. With the container name, run `docker exec -it <CONTAINER>
+  /bin/bash` where `<CONTAINER>` is the container name like `4ba195e95cef`.
+
+[Docker]: https://www.docker.com/
+[`src/ci/docker`]: https://github.com/rust-lang/rust/tree/master/src/ci/docker
+[`src/ci/docker/run.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/docker/run.sh
+[`src/ci/run.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/run.sh
+[`enable-docker-ipv6.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/scripts/enable-docker-ipv6.sh
diff --git a/src/doc/rustc-dev-guide/src/tests/headers.md b/src/doc/rustc-dev-guide/src/tests/headers.md
new file mode 100644
index 000000000..bfa637f34
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/headers.md
@@ -0,0 +1,405 @@
+# Test headers
+
+<!-- toc -->
+
+Header commands are special comments that tell compiletest how to build and
+interpret a test.
+They must appear before the Rust source in the test.
+They may also appear in Makefiles for [run-make tests](compiletest.md#run-make-tests).
+
+They are normally put after the short comment that explains the point of this test.
+For example, this test uses the `// compile-flags` command to specify a custom
+flag to give to rustc when the test is compiled:
+
+```rust,ignore
+// Test the behavior of `0 - 1` when overflow checks are disabled.
+
+// compile-flags: -C overflow-checks=off
+
+fn main() {
+    let x = 0 - 1;
+    ...
+}
+```
+
+Header commands can be standalone (like `// run-pass`) or take a value (like
+`// compile-flags: -C overflow-checks=off`).
+
+## Header commands
+
+The following is a list of header commands.
+Commands are linked to sections the describe the command in more detail if available.
+This list may not be exhaustive.
+Header commands can generally be found by browsing the `TestProps` structure
+found in [`header.rs`] from the compiletest source.
+
+[`header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/header.rs
+
+* [Controlling pass/fail expectations](ui.md#controlling-passfail-expectations)
+    * `check-pass` — building (no codegen) should pass
+    * `build-pass` — building should pass
+    * `run-pass` — running the test should pass
+    * `check-fail` — building (no codegen) should fail (the default if no header)
+    * `build-fail` — building should fail
+    * `run-fail` — running should fail
+    * `ignore-pass` — ignores the `--pass` flag
+    * `check-run-results` — checks run-pass/fail-pass output
+* [UI](ui.md) headers
+    * [`normalize-X`](ui.md#normalization) — normalize compiler output
+    * [`run-rustfix`](ui.md#rustfix-tests) — checks diagnostic suggestions
+    * [`rustfix-only-machine-applicable`](ui.md#rustfix-tests) — checks only
+      machine applicable suggestions
+    * [`stderr-per-bitwidth`](ui.md#output-comparison) — separate output per bit width
+    * [`dont-check-compiler-stderr`](ui.md#output-comparison) — don't validate stderr
+    * [`dont-check-compiler-stdout`](ui.md#output-comparison) — don't validate stdout
+* [Building auxiliary crates](compiletest.md#building-auxiliary-crates)
+    * `aux-build`
+    * `aux-crate`
+* [Pretty-printer](compiletest.md#pretty-printer-tests) headers
+    * `pretty-compare-only`
+    * `pretty-expanded`
+    * `pretty-mode`
+    * `pp-exact`
+* [Ignoring tests](#ignoring-tests)
+    * `ignore-X`
+    * `only-X`
+    * `needs-X`
+    * `no-system-llvm`
+    * `min-llvm-versionX`
+    * `min-system-llvm-version`
+    * `ignore-llvm-version`
+    * `ignore-llvm-version`
+* [Environment variable headers](#environment-variable-headers)
+    * `rustc-env`
+    * `exec-env`
+    * `unset-rustc-env`
+* [Miscellaneous headers](#miscellaneous-headers)
+    * `compile-flags` — adds compiler flags
+    * `run-flags` — adds flags to executable tests
+    * `edition` — sets the edition
+    * `failure-status` — expected exit code
+    * `should-fail` — testing compiletest itself
+    * `gate-test-X` — feature gate testing
+    * [`error-pattern`](ui.md#error-pattern) — errors not on a line
+    * `incremental` — incremental tests not in the incremental test-suite
+    * `no-prefer-dynamic` — don't use `-C prefer-dynamic`, don't build as a dylib
+    * `force-host` — build only for the host target
+    * [`revisions`](compiletest.md#revisions) — compile multiple times
+    * [`forbid-output`](compiletest.md#incremental-tests) — incremental cfail rejects output pattern
+    * [`should-ice`](compiletest.md#incremental-tests) — incremental cfail should ICE
+    * [`known-bug`](ui.md#known-bugs) — indicates that the test is
+      for a known bug that has not yet been fixed
+* [Assembly](compiletest.md#assembly-tests) headers
+    * `assembly-output` — the type of assembly output to check
+
+
+### Ignoring tests
+
+These header commands are used to ignore the test in some situations,
+which means the test won't be compiled or run.
+
+* `ignore-X` where `X` is a target detail or stage will ignore the
+  test accordingly (see below)
+* `only-X` is like `ignore-X`, but will *only* run the test on that
+  target or stage
+* `ignore-test` always ignores the test.
+  This can be used to temporarily disable a test if it is currently not working,
+  but you want to keep it in tree to re-enable it later.
+
+Some examples of `X` in `ignore-X` or `only-X`:
+
+* A full target triple: `aarch64-apple-ios`
+* Architecture: `aarch64`, `arm`, `asmjs`, `mips`, `wasm32`, `x86_64`,
+  `x86`, ...
+* OS: `android`, `emscripten`, `freebsd`, `ios`, `linux`, `macos`,
+  `windows`, ...
+* Environment (fourth word of the target triple): `gnu`, `msvc`,
+  `musl`
+* WASM: `wasm32-bare` matches `wasm32-unknown-unknown`.
+  `emscripten` also matches that target as well as the emscripten targets.
+* Pointer width: `32bit`, `64bit`
+* Endianness: `endian-big`
+* Stage: `stage0`, `stage1`, `stage2`
+* Channel: `stable`, `beta`
+* When cross compiling: `cross-compile`
+* When [remote testing] is used: `remote`
+* When debug-assertions are enabled: `debug`
+* When particular debuggers are being tested: `cdb`, `gdb`, `lldb`
+* Specific [compare modes]: `compare-mode-polonius`,
+  `compare-mode-chalk`, `compare-mode-split-dwarf`,
+  `compare-mode-split-dwarf-single`
+
+The following header commands will check rustc build settings and target settings:
+
+* `needs-asm-support` — ignores if it is running on a target that doesn't have
+  stable support for `asm!`
+* `needs-profiler-support` — ignores if profiler support was not enabled for
+  the target (`profiler = true` in rustc's `config.toml`)
+* `needs-sanitizer-support` — ignores if the sanitizer support was not enabled
+  for the target (`sanitizers = true` in rustc's `config.toml`)
+* `needs-sanitizer-{address,hwaddress,leak,memory,thread}` — ignores
+  if the corresponding sanitizer is not enabled for the target
+  (AddressSanitizer, hardware-assisted AddressSanitizer, LeakSanitizer,
+  MemorySanitizer or ThreadSanitizer respectively)
+* `needs-run-enabled` — ignores if it is a test that gets executed, and
+  running has been disabled. Running tests can be disabled with the `x.py test
+  --run=never` flag, or running on fuchsia.
+* `needs-unwind` — ignores if the target does not support unwinding
+* `needs-rust-lld` — ignores if the rust lld support is not enabled
+  (`rust.lld = true` in `config.toml`)
+
+The following header commands will check LLVM support:
+
+* `no-system-llvm` — ignores if the system llvm is used
+* `min-llvm-version: 13.0` — ignored if the LLVM version is less than the given value
+* `min-system-llvm-version: 12.0` — ignored if using a system LLVM and its
+  version is less than the given value
+* `ignore-llvm-version: 9.0` — ignores a specific LLVM version
+* `ignore-llvm-version: 7.0 - 9.9.9` — ignores LLVM versions in a range (inclusive)
+* `needs-llvm-components: powerpc` — ignores if the specific LLVM component was not built.
+  Note: The test will fail on CI if the component does not exist.
+* `needs-matching-clang` — ignores if the version of clang does not match the
+  LLVM version of rustc.
+  These tests are always ignored unless a special environment variable is set
+  (which is only done in one CI job).
+
+See also [Debuginfo tests](compiletest.md#debuginfo-tests) for headers for
+ignoring debuggers.
+
+[remote testing]: running.md#running-tests-on-a-remote-machine
+[compare modes]: ui.md#compare-modes
+
+### Environment variable headers
+
+The following headers affect environment variables.
+
+* `rustc-env` is an environment variable to set when running `rustc` of the
+  form `KEY=VALUE`.
+* `exec-env` is an environment variable to set when executing a test of the
+  form `KEY=VALUE`.
+* `unset-rustc-env` specifies an environment variable to unset when running
+  `rustc`.
+
+### Miscellaneous headers
+
+The following headers are generally available, and not specific to particular
+test suites.
+
+* `compile-flags` passes extra command-line args to the compiler,
+  e.g. `compile-flags -g` which forces debuginfo to be enabled.
+* `run-flags` passes extra args to the test if the test is to be executed.
+* `edition` controls the edition the test should be compiled with
+  (defaults to 2015). Example usage: `// edition:2018`.
+* `failure-status` specifies the numeric exit code that should be expected for
+  tests that expect an error.
+  If this is not set, the default is 1.
+* `should-fail` indicates that the test should fail; used for "meta
+  testing", where we test the compiletest program itself to check that
+  it will generate errors in appropriate scenarios. This header is
+  ignored for pretty-printer tests.
+* `gate-test-X` where `X` is a feature marks the test as "gate test"
+  for feature X.
+  Such tests are supposed to ensure that the compiler errors when usage of a
+  gated feature is attempted without the proper `#![feature(X)]` tag.
+  Each unstable lang feature is required to have a gate test.
+  This header is actually checked by [tidy](intro.md#tidy), it is not checked
+  by compiletest.
+* `error-pattern` checks the diagnostics just like the `ERROR` annotation
+  without specifying error line. This is useful when the error doesn't give
+  any span. See [`error-pattern`](ui.md#error-pattern).
+* `incremental` runs the test with the `-C incremental` flag and an empty
+  incremental directory. This should be avoided when possible; you should use
+  an *incremental mode* test instead. Incremental mode tests support running
+  the compiler multiple times and verifying that it can load the generated
+  incremental cache. This flag is for specialized circumstances, like checking
+  the interaction of codegen unit partitioning with generating an incremental
+  cache.
+* `no-prefer-dynamic` will force an auxiliary crate to be built as an rlib
+  instead of a dylib. When specified in a test, it will remove the use of `-C
+  prefer-dynamic`. This can be useful in a variety of circumstances. For
+  example, it can prevent a proc-macro from being built with the wrong crate
+  type. Or if your test is specifically targeting behavior of other crate
+  types, it can be used to prevent building with the wrong crate type.
+* `force-host` will force the test to build for the host platform instead of
+  the target. This is useful primarily for auxiliary proc-macros, which need
+  to be loaded by the host compiler.
+
+
+## Substitutions
+
+Headers values support substituting a few variables which will be replaced
+with their corresponding value.
+For example, if you need to pass a compiler flag with a path to a specific
+file, something like the following could work:
+
+```rust,ignore
+// compile-flags: --remap-path-prefix={{src-base}}=/the/src
+```
+
+Where the sentinel `{{src-base}}` will be replaced with the appropriate path
+described below:
+
+- `{{cwd}}`: The directory where compiletest is run from. This may not be the
+  root of the checkout, so you should avoid using it where possible.
+  - Examples: `/path/to/rust`, `/path/to/build/root`
+- `{{src-base}}`: The directory where the test is defined. This is equivalent to
+  `$DIR` for [output normalization].
+  - Example: `/path/to/rust/src/test/ui/error-codes`
+- `{{build-base}}`: The base directory where the test's output goes. This is
+  equivalent to `$TEST_BUILD_DIR` for [output normalization].
+  - Example: `/path/to/rust/build/x86_64-unknown-linux-gnu/test/ui`
+
+See [`src/test/ui/commandline-argfile.rs`](https://github.com/rust-lang/rust/blob/a5029ac0ab372aec515db2e718da6d7787f3d122/src/test/ui/commandline-argfile.rs)
+for an example of a test that uses this substitution.
+
+[output normalization]: ui.md#normalization
+
+
+## Adding a new header command
+
+One would add a new header command if there is a need to define some test
+property or behavior on an individual, test-by-test basis.
+A header command property serves as the header command's backing store (holds
+the command's current value) at runtime.
+
+To add a new header command property:
+
+  1. Look for the `pub struct TestProps` declaration in
+     [`src/tools/compiletest/src/header.rs`] and add the new public property to
+     the end of the declaration.
+  2. Look for the `impl TestProps` implementation block immediately following
+     the struct declaration and initialize the new property to its default
+     value.
+
+### Adding a new header command parser
+
+When `compiletest` encounters a test file, it parses the file a line at a time
+by calling every parser defined in the `Config` struct's implementation block,
+also in [`src/tools/compiletest/src/header.rs`] (note that the `Config`
+struct's declaration block is found in [`src/tools/compiletest/src/common.rs`]).
+`TestProps`'s `load_from()` method will try passing the current line of text to
+each parser, which, in turn typically checks to see if the line begins with a
+particular commented (`//`) header command such as `// must-compile-successfully`
+or `// failure-status`. Whitespace after the comment marker is optional.
+
+Parsers will override a given header command property's default value merely by
+being specified in the test file as a header command or by having a parameter
+value specified in the test file, depending on the header command.
+
+Parsers defined in `impl Config` are typically named `parse_<header_command>`
+(note kebab-case `<header-command>` transformed to snake-case
+`<header_command>`). `impl Config` also defines several 'low-level' parsers
+which make it simple to parse common patterns like simple presence or not
+(`parse_name_directive()`), header-command:parameter(s)
+(`parse_name_value_directive()`), optional parsing only if a particular `cfg`
+attribute is defined (`has_cfg_prefix()`) and many more. The low-level parsers
+are found near the end of the `impl Config` block; be sure to look through them
+and their associated parsers immediately above to see how they are used to
+avoid writing additional parsing code unnecessarily.
+
+As a concrete example, here is the implementation for the
+`parse_failure_status()` parser, in [`src/tools/compiletest/src/header.rs`]:
+
+```diff
+@@ -232,6 +232,7 @@ pub struct TestProps {
+     // customized normalization rules
+     pub normalize_stdout: Vec<(String, String)>,
+     pub normalize_stderr: Vec<(String, String)>,
++    pub failure_status: i32,
+ }
+
+ impl TestProps {
+@@ -260,6 +261,7 @@ impl TestProps {
+             run_pass: false,
+             normalize_stdout: vec![],
+             normalize_stderr: vec![],
++            failure_status: 101,
+         }
+     }
+
+@@ -383,6 +385,10 @@ impl TestProps {
+             if let Some(rule) = config.parse_custom_normalization(ln, "normalize-stderr") {
+                 self.normalize_stderr.push(rule);
+             }
++
++            if let Some(code) = config.parse_failure_status(ln) {
++                self.failure_status = code;
++            }
+         });
+
+         for key in &["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
+@@ -488,6 +494,13 @@ impl Config {
+         self.parse_name_directive(line, "pretty-compare-only")
+     }
+
++    fn parse_failure_status(&self, line: &str) -> Option<i32> {
++        match self.parse_name_value_directive(line, "failure-status") {
++            Some(code) => code.trim().parse::<i32>().ok(),
++            _ => None,
++        }
++    }
+```
+
+### Implementing the behavior change
+
+When a test invokes a particular header command, it is expected that some
+behavior will change as a result. What behavior, obviously, will depend on the
+purpose of the header command. In the case of `failure-status`, the behavior
+that changes is that `compiletest` expects the failure code defined by the
+header command invoked in the test, rather than the default value.
+
+Although specific to `failure-status` (as every header command will have a
+different implementation in order to invoke behavior change) perhaps it is
+helpful to see the behavior change implementation of one case, simply as an
+example. To implement `failure-status`, the `check_correct_failure_status()`
+function found in the `TestCx` implementation block, located in
+[`src/tools/compiletest/src/runtest.rs`], was modified as per below:
+
+```diff
+@@ -295,11 +295,14 @@ impl<'test> TestCx<'test> {
+     }
+
+     fn check_correct_failure_status(&self, proc_res: &ProcRes) {
+-        // The value the Rust runtime returns on failure
+-        const RUST_ERR: i32 = 101;
+-        if proc_res.status.code() != Some(RUST_ERR) {
++        let expected_status = Some(self.props.failure_status);
++        let received_status = proc_res.status.code();
++
++        if expected_status != received_status {
+             self.fatal_proc_rec(
+-                &format!("failure produced the wrong error: {}", proc_res.status),
++                &format!("Error: expected failure status ({:?}) but received status {:?}.",
++                         expected_status,
++                         received_status),
+                 proc_res,
+             );
+         }
+@@ -320,7 +323,6 @@ impl<'test> TestCx<'test> {
+         );
+
+         let proc_res = self.exec_compiled_test();
+-
+         if !proc_res.status.success() {
+             self.fatal_proc_rec("test run failed!", &proc_res);
+         }
+@@ -499,7 +501,6 @@ impl<'test> TestCx<'test> {
+                 expected,
+                 actual
+             );
+-            panic!();
+         }
+     }
+```
+
+Note the use of `self.props.failure_status` to access the header command
+property. In tests which do not specify the failure status header command,
+`self.props.failure_status` will evaluate to the default value of 101 at the
+time of this writing. But for a test which specifies a header command of, for
+example, `// failure-status: 1`, `self.props.failure_status` will evaluate to
+1, as `parse_failure_status()` will have overridden the `TestProps` default
+value, for that test specifically.
+
+[`src/tools/compiletest/src/header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/header.rs
+[`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/common.rs
+[`src/tools/compiletest/src/runtest.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/runtest.rs
diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
new file mode 100644
index 000000000..8b65e4df5
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -0,0 +1,161 @@
+# Testing the compiler
+
+<!-- toc -->
+
+The Rust project runs a wide variety of different tests, orchestrated by
+the build system (`./x.py test`).
+This section gives a brief overview of the different testing tools.
+Subsequent chapters dive into [running tests](running.md) and [adding new tests](adding.md).
+
+## Kinds of tests
+
+There are several kinds of tests to exercise things in the Rust distribution.
+Almost all of them are driven by `./x.py test`, with some exceptions noted below.
+
+### Compiletest
+
+The main test harness for testing the compiler itself is a tool called [compiletest].
+It supports running different styles of tests, called *test suites*.
+The tests are all located in the [`src/test`] directory.
+The [Compiletest chapter][compiletest] goes into detail on how to use this tool.
+
+> Example: `./x.py test src/test/ui`
+
+[compiletest]: compiletest.md
+[`src/test`]: https://github.com/rust-lang/rust/tree/master/src/test
+
+### Package tests
+
+The standard library and many of the compiler packages include typical Rust `#[test]`
+unit tests, integration tests, and documentation tests.
+You can pass a path to `x.py` to almost any package in the `library` or `compiler` directory,
+and `x.py` will essentially run `cargo test` on that package.
+
+Examples:
+
+| Command | Description |
+|---------|-------------|
+| `./x.py test library/std` | Runs tests on `std` only |
+| `./x.py test library/core` | Runs tests on `core` only |
+| `./x.py test compiler/rustc_data_structures` | Runs tests on `rustc_data_structures` |
+
+The standard library relies very heavily on documentation tests to cover its functionality.
+However, unit tests and integration tests can also be used as needed.
+Almost all of the compiler packages have doctests disabled.
+
+The standard library and compiler always place all unit tests in a separate `tests` file
+(this is enforced in [tidy][tidy-unit-tests]).
+This approach ensures that when the test file is changed, the crate does not need to be recompiled.
+For example:
+
+```rust,ignore
+#[cfg(test)]
+mod tests;
+```
+
+If it wasn't done this way, and the tests were placed in the same file as the source,
+then changing or adding a test would cause the crate you are working on to be recompiled.
+If you were working on something like `core`,
+then that would require recompiling the entire standard library, and the entirety of `rustc`.
+
+`./x.py test` includes some CLI options for controlling the behavior with these tests:
+
+* `--doc` — Only runs documentation tests in the package.
+* `--no-doc` — Run all tests *except* documentation tests.
+
+[tidy-unit-tests]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/src/unit_tests.rs
+
+### Tidy
+
+Tidy is a custom tool used for validating source code style and formatting conventions,
+such as rejecting long lines.
+There is more information in the [section on coding conventions](../conventions.md#formatting).
+
+> Example: `./x.py test tidy`
+
+### Formatting
+
+Rustfmt is integrated with the build system to enforce uniform style across the compiler.
+The formatting check is automatically run by the Tidy tool mentioned above.
+
+Examples:
+
+| Command | Description |
+|---------|-------------|
+| `./x.py fmt --check` | Checks formatting and exits with an error if formatting is needed. |
+| `./x.py fmt` | Runs rustfmt across the entire codebase. |
+| `./x.py test tidy --bless` | First runs rustfmt to format the codebase, then runs tidy checks. |
+
+### Book documentation tests
+
+All of the books that are published have their own tests,
+primarily for validating that the Rust code examples pass.
+Under the hood, these are essentially using `rustdoc --test` on the markdown files.
+The tests can be run by passing a path to a book to `./x.py test`.
+
+> Example: `./x.py test src/doc/book`
+
+### Documentation link checker
+
+Links across all documentation is validated with a link checker tool.
+
+> Example: `./x.py test src/tools/linkchecker`
+
+> Example: `./x.py test linkchecker`
+
+This requires building all of the documentation, which might take a while.
+
+### Dist check
+
+`distcheck` verifies that the source distribution tarball created by the build system
+will unpack, build, and run all tests.
+
+> Example: `./x.py test distcheck`
+
+### Tool tests
+
+Packages that are included with Rust have all of their tests run as well.
+This includes things such as cargo, clippy, rustfmt, rls, miri, bootstrap
+(testing the Rust build system itself), etc.
+
+Most of the tools are located in the [`src/tools`] directory.
+To run the tool's tests, just pass its path to `./x.py test`.
+
+> Example: `./x.py test src/tools/cargo`
+
+Usually these tools involve running `cargo test` within the tool's directory.
+
+In CI, some tools are allowed to fail.
+Failures send notifications to the corresponding teams, and is tracked on the [toolstate website].
+More information can be found in the [toolstate documentation].
+
+[`src/tools`]: https://github.com/rust-lang/rust/tree/master/src/tools/
+[toolstate documentation]: https://forge.rust-lang.org/infra/toolstate.html
+[toolstate website]: https://rust-lang-nursery.github.io/rust-toolstate/
+
+### Cargo test
+
+`cargotest` is a small tool which runs `cargo test` on a few sample projects
+(such as `servo`, `ripgrep`, `tokei`, etc.).
+This ensures there aren't any significant regressions.
+
+> Example: `./x.py test src/tools/cargotest`
+
+### Crater
+
+Crater is a tool which runs tests on many thousands of public projects.
+This tool has its own separate infrastructure for running.
+See the [Crater chapter](crater.md) for more details.
+
+### Performance testing
+
+A separate infrastructure is used for testing and tracking performance of the compiler.
+See the [Performance testing chapter](perf.md) for more details.
+
+## Further reading
+
+The following blog posts may also be of interest:
+
+- brson's classic ["How Rust is tested"][howtest]
+
+[howtest]: https://brson.github.io/2017/07/10/how-rust-is-tested
diff --git a/src/doc/rustc-dev-guide/src/tests/perf.md b/src/doc/rustc-dev-guide/src/tests/perf.md
new file mode 100644
index 000000000..ac65faff1
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/perf.md
@@ -0,0 +1,50 @@
+# Performance testing
+
+## rustc-perf
+
+A lot of work is put into improving the performance of the compiler and
+preventing performance regressions.
+The [rustc-perf](https://github.com/rust-lang/rustc-perf) project provides
+several services for testing and tracking performance.
+It provides hosted infrastructure for running benchmarks as a service.
+At this time, only `x86_64-unknown-linux-gnu` builds are tracked.
+
+A "perf run" is used to compare the performance of the compiler in different
+configurations for a large collection of popular crates.
+Different configurations include "fresh builds", builds with incremental compilation, etc.
+
+The result of a perf run is a comparison between two versions of the compiler
+(by their commit hashes).
+
+### Automatic perf runs
+
+After every PR is merged, a suite of benchmarks are run against the compiler.
+The results are tracked over time on the <https://perf.rust-lang.org/> website.
+Any changes are noted in a comment on the PR.
+
+### Manual perf runs
+
+Additionally, performance tests can be ran before a PR is merged on an as-needed basis.
+You should request a perf run if your PR may affect performance, especially if
+it can affect performance adversely.
+
+To evaluate the performance impact of a PR, write this comment on the PR:
+
+`@bors try @rust-timer queue`
+
+> **Note**: Only users authorized to do perf runs are allowed to post this comment.
+> Teams that are allowed to use it are tracked in the [Teams
+> repository](https://github.com/rust-lang/team) with the `perf = true` value
+> in the `[permissions]` section (and bors permissions are also required).
+> If you are not on one of those teams, feel free to ask for someone to post
+> it for you (either on Zulip or ask the assigned reviewer).
+
+This will first tell bors to do a "try" build which do a full release build
+for `x86_64-unknown-linux-gnu`.
+After the build finishes, it will place it in the queue to run the performance
+suite against it.
+After the performance tests finish, the bot will post a comment on the PR with
+a summary and a link to a full report.
+
+More details are available in the [perf collector
+documentation](https://github.com/rust-lang/rustc-perf/blob/master/collector/README.md).
diff --git a/src/doc/rustc-dev-guide/src/tests/running.md b/src/doc/rustc-dev-guide/src/tests/running.md
new file mode 100644
index 000000000..be9d965e4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/running.md
@@ -0,0 +1,328 @@
+# Running tests
+
+<!-- toc -->
+
+You can run the tests using `x.py`. The most basic command – which
+you will almost never want to use! – is as follows:
+
+```bash
+./x.py test
+```
+
+This will build the stage 1 compiler and then run the whole test
+suite. You probably don't want to do this very often, because it takes
+a very long time, and anyway bors / GitHub Actions will do it for you.
+(Often, I will run this command in the background after opening a PR that
+I think is done, but rarely otherwise. -nmatsakis)
+
+The test results are cached and previously successful tests are
+`ignored` during testing. The stdout/stderr contents as well as a
+timestamp file for every test can be found under `build/ARCH/test/`.
+To force-rerun a test (e.g. in case the test runner fails to notice a change)
+you can simply remove the timestamp file, or use the `--force-rerun` CLI
+option.
+
+Note that some tests require a Python-enabled gdb. You can test if
+your gdb install supports Python by using the `python` command from
+within gdb. Once invoked you can type some Python code (e.g.
+`print("hi")`) followed by return and then `CTRL+D` to execute it.
+If you are building gdb from source, you will need to configure with
+`--with-python=<path-to-python-binary>`.
+
+## Running a subset of the test suites
+
+When working on a specific PR, you will usually want to run a smaller
+set of tests. For example, a good "smoke test" that can be used after
+modifying rustc to see if things are generally working correctly would be the
+following:
+
+```bash
+./x.py test src/test/ui
+```
+
+This will run the `ui` test suite. Of course, the choice
+of test suites is somewhat arbitrary, and may not suit the task you are
+doing. For example, if you are hacking on debuginfo, you may be better off
+with the debuginfo test suite:
+
+```bash
+./x.py test src/test/debuginfo
+```
+
+If you only need to test a specific subdirectory of tests for any
+given test suite, you can pass that directory to `./x.py test`:
+
+```bash
+./x.py test src/test/ui/const-generics
+```
+
+Likewise, you can test a single file by passing its path:
+
+```bash
+./x.py test src/test/ui/const-generics/const-test.rs
+```
+
+### Run only the tidy script
+
+```bash
+./x.py test tidy
+```
+
+### Run tests on the standard library
+
+```bash
+./x.py test --stage 0 library/std
+```
+
+Note that this only runs tests on `std`; if you want to test `core` or other crates,
+you have to specify those explicitly.
+
+### Run the tidy script and tests on the standard library
+
+```bash
+./x.py test --stage 0 tidy library/std
+```
+
+### Run tests on the standard library using a stage 1 compiler
+
+```bash
+./x.py test --stage 1 library/std
+```
+
+By listing which test suites you want to run you avoid having to run
+tests for components you did not change at all.
+
+**Warning:** Note that bors only runs the tests with the full stage 2
+build; therefore, while the tests **usually** work fine with stage 1,
+there are some limitations.
+
+### Run all tests using a stage 2 compiler
+
+```bash
+./x.py test --stage 2
+```
+You almost never need to do this; CI will run these tests for you.
+
+## Run unit tests on the compiler/library
+
+You may want to run unit tests on a specific file with following:
+
+```bash
+./x.py test compiler/rustc_data_structures/src/thin_vec/tests.rs
+```
+
+But unfortunately, it's impossible. You should invoke following instead:
+
+```bash
+./x.py test compiler/rustc_data_structures/ --test-args thin_vec
+```
+
+## Running an individual test
+
+Another common thing that people want to do is to run an **individual
+test**, often the test they are trying to fix. As mentioned earlier,
+you may pass the full file path to achieve this, or alternatively one
+may invoke `x.py` with the `--test-args` option:
+
+```bash
+./x.py test src/test/ui --test-args issue-1234
+```
+
+Under the hood, the test runner invokes the standard Rust test runner
+(the same one you get with `#[test]`), so this command would wind up
+filtering for tests that include "issue-1234" in the name. (Thus
+`--test-args` is a good way to run a collection of related tests.)
+
+## Editing and updating the reference files
+
+If you have changed the compiler's output intentionally, or you are
+making a new test, you can pass `--bless` to the test subcommand. E.g.
+if some tests in `src/test/ui` are failing, you can run
+
+```text
+./x.py test src/test/ui --bless
+```
+
+to automatically adjust the `.stderr`, `.stdout` or `.fixed` files of
+all tests. Of course you can also target just specific tests with the
+`--test-args your_test_name` flag, just like when running the tests.
+
+## Configuring test running
+
+There are a few options for running tests:
+
+* `config.toml` has the `rust.verbose-tests` option.
+  If `false`, each test will print a single dot (the default).
+  If `true`, the name of every test will be printed.
+  This is equivalent to the `--quiet` option in the [Rust test
+  harness](https://doc.rust-lang.org/rustc/tests/)
+* The environment variable `RUST_TEST_THREADS` can be set to the number of
+  concurrent threads to use for testing.
+
+## Passing `--pass $mode`
+
+Pass UI tests now have three modes, `check-pass`, `build-pass` and
+`run-pass`. When `--pass $mode` is passed, these tests will be forced
+to run under the given `$mode` unless the directive `// ignore-pass`
+exists in the test file. For example, you can run all the tests in
+`src/test/ui` as `check-pass`:
+
+```bash
+./x.py test src/test/ui --pass check
+```
+
+By passing `--pass $mode`, you can reduce the testing time. For each
+mode, please see [Controlling pass/fail
+expectations](ui.md#controlling-passfail-expectations).
+
+## Using incremental compilation
+
+You can further enable the `--incremental` flag to save additional
+time in subsequent rebuilds:
+
+```bash
+./x.py test src/test/ui --incremental --test-args issue-1234
+```
+
+If you don't want to include the flag with every command, you can
+enable it in the `config.toml`:
+
+```toml
+[rust]
+incremental = true
+```
+
+Note that incremental compilation will use more disk space than usual.
+If disk space is a concern for you, you might want to check the size
+of the `build` directory from time to time.
+
+## Running tests with different "compare modes"
+
+UI tests may have different output depending on certain "modes" that
+the compiler is in. For example, when using the Polonius
+mode, a test `foo.rs` will first look for expected output in
+`foo.polonius.stderr`, falling back to the usual `foo.stderr` if not found.
+The following will run the UI test suite in Polonius mode:
+
+```bash
+./x.py test src/test/ui --compare-mode=polonius
+```
+
+See [Compare modes](compiletest.md#compare-modes) for more details.
+
+## Running tests manually
+
+Sometimes it's easier and faster to just run the test by hand.
+Most tests are just `rs` files, so after
+[creating a rustup toolchain](../building/how-to-build-and-run.md#creating-a-rustup-toolchain),
+you can do something like:
+
+```bash
+rustc +stage1 src/test/ui/issue-1234.rs
+```
+
+This is much faster, but doesn't always work. For example, some tests
+include directives that specify specific compiler flags, or which rely
+on other crates, and they may not run the same without those options.
+
+
+## Running tests on a remote machine
+
+Tests may be run on a remote machine (e.g. to test builds for a different
+architecture). This is done using `remote-test-client` on the build machine
+to send test programs to `remote-test-server` running on the remote machine.
+`remote-test-server` executes the test programs and sends the results back to
+the build machine. `remote-test-server` provides *unauthenticated remote code
+execution* so be careful where it is used.
+
+To do this, first build `remote-test-server` for the remote
+machine, e.g. for RISC-V
+```sh
+./x.py build src/tools/remote-test-server --target riscv64gc-unknown-linux-gnu
+```
+
+The binary will be created at
+`./build/$HOST_ARCH/stage2-tools/$TARGET_ARCH/release/remote-test-server`. Copy
+this over to the remote machine.
+
+On the remote machine, run the `remote-test-server` with the `remote` argument
+(and optionally `-v` for verbose output). Output should look like this:
+```sh
+$ ./remote-test-server -v remote
+starting test server
+listening on 0.0.0.0:12345!
+```
+
+You can test if the `remote-test-server` is working by connecting to it and
+sending `ping\n`. It should reply `pong`:
+```sh
+$ nc $REMOTE_IP 12345
+ping
+pong
+```
+
+To run tests using the remote runner, set the `TEST_DEVICE_ADDR` environment
+variable then use `x.py` as usual. For example, to run `ui` tests for a RISC-V
+machine with the IP address `1.2.3.4` use
+```sh
+export TEST_DEVICE_ADDR="1.2.3.4:12345"
+./x.py test src/test/ui --target riscv64gc-unknown-linux-gnu
+```
+
+If `remote-test-server` was run with the verbose flag, output on the test machine
+may look something like
+```
+[...]
+run "/tmp/work/test1007/a"
+run "/tmp/work/test1008/a"
+run "/tmp/work/test1009/a"
+run "/tmp/work/test1010/a"
+run "/tmp/work/test1011/a"
+run "/tmp/work/test1012/a"
+run "/tmp/work/test1013/a"
+run "/tmp/work/test1014/a"
+run "/tmp/work/test1015/a"
+run "/tmp/work/test1016/a"
+run "/tmp/work/test1017/a"
+run "/tmp/work/test1018/a"
+[...]
+```
+
+Tests are built on the machine running `x.py` not on the remote machine. Tests
+which fail to build unexpectedly (or `ui` tests producing incorrect build
+output) may fail without ever running on the remote machine.
+
+## Testing on emulators
+
+Some platforms are tested via an emulator for architectures that aren't
+readily available. For architectures where the standard library is well
+supported and the host operating system supports TCP/IP networking, see the
+above instructions for testing on a remote machine (in this case the
+remote machine is emulated).
+
+There is also a set of tools for orchestrating running the
+tests within the emulator. Platforms such as `arm-android` and
+`arm-unknown-linux-gnueabihf` are set up to automatically run the tests under
+emulation on GitHub Actions. The following will take a look at how a target's tests
+are run under emulation.
+
+The Docker image for [armhf-gnu] includes [QEMU] to emulate the ARM CPU
+architecture. Included in the Rust tree are the tools [remote-test-client]
+and [remote-test-server] which are programs for sending test programs and
+libraries to the emulator, and running the tests within the emulator, and
+reading the results.  The Docker image is set up to launch
+`remote-test-server` and the build tools use `remote-test-client` to
+communicate with the server to coordinate running tests (see
+[src/bootstrap/test.rs]).
+
+> TODO:
+> Is there any support for using an iOS emulator?
+>
+> It's also unclear to me how the wasm or asm.js tests are run.
+
+[armhf-gnu]: https://github.com/rust-lang/rust/tree/master/src/ci/docker/host-x86_64/armhf-gnu/Dockerfile
+[QEMU]: https://www.qemu.org/
+[remote-test-client]: https://github.com/rust-lang/rust/tree/master/src/tools/remote-test-client
+[remote-test-server]: https://github.com/rust-lang/rust/tree/master/src/tools/remote-test-server
+[src/bootstrap/test.rs]: https://github.com/rust-lang/rust/tree/master/src/bootstrap/test.rs
+
diff --git a/src/doc/rustc-dev-guide/src/tests/ui.md b/src/doc/rustc-dev-guide/src/tests/ui.md
new file mode 100644
index 000000000..1baa447a0
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tests/ui.md
@@ -0,0 +1,514 @@
+# UI tests
+
+<!-- toc -->
+
+UI tests are a particular [test suite](compiletest.md#test-suites) of compiletest.
+
+## Introduction
+
+The tests in [`src/test/ui`] are a collection of general-purpose tests which
+primarily focus on validating the console output of the compiler, but can be
+used for many other purposes.
+For example, tests can also be configured to [run the resulting
+program](#controlling-passfail-expectations) to verify its behavior.
+
+[`src/test/ui`]: https://github.com/rust-lang/rust/blob/master/src/test/ui
+
+## General structure of a test
+
+A test consists of a Rust source file located anywhere in the `src/test/ui` directory.
+For example, [`src/test/ui/hello.rs`] is a basic hello-world test.
+
+Compiletest will use `rustc` to compile the test, and compare the output
+against the expected output which is stored in a `.stdout` or `.stderr` file
+located next to the test.
+See [Output comparison](#output-comparison) for more.
+
+Additionally, errors and warnings should be annotated with comments within
+the source file.
+See [Error annotations](#error-annotations) for more.
+
+[Headers](headers.md) in the form of comments at the top of the file control
+how the test is compiled and what the expected behavior is.
+
+Tests are expected to fail to compile, since most tests are testing compiler
+errors.
+You can change that behavior with a header, see [Controlling pass/fail
+expectations](#controlling-passfail-expectations).
+
+By default, a test is built as an executable binary.
+If you need a different crate type, you can use the `#![crate_type]` attribute
+to set it as needed.
+
+[`src/test/ui/hello.rs`]: https://github.com/rust-lang/rust/blob/master/src/test/ui/hello.rs
+
+## Output comparison
+
+UI tests store the expected output from the compiler in `.stderr` and
+`.stdout` files next to the test.
+You normally generate these files with the `--bless` CLI option, and then
+inspect them manually to verify they contain what you expect.
+
+The output is normalized to ignore unwanted differences, see the
+[Normalization](#normalization) section.
+If the file is missing, then compiletest expects the corresponding output to
+be empty.
+
+There can be multiple stdout/stderr files.
+The general form is:
+
+*test-name*`.`*revision*`.`*compare_mode*`.`*extension*
+
+* *revision* is the [revision](#cfg-revisions) name.
+  This is not included when not using revisions.
+* *compare_mode* is the [compare mode](#compare-modes).
+  This will only be checked when the given compare mode is active.
+  If the file does not exist, then compiletest will check for a file without
+  the compare mode.
+* *extension* is the kind of output being checked:
+  * `stderr` — compiler stderr
+  * `stdout` — compiler stdout
+  * `run.stderr` — stderr when running the test
+  * `run.stdout` — stdout when running the test
+  * `64bit.stderr` — compiler stderr with `stderr-per-bitwidth` header on a 64-bit target
+  * `32bit.stderr` — compiler stderr with `stderr-per-bitwidth` header on a 32-bit target
+
+A simple example would be `foo.stderr` next to a `foo.rs` test.
+A more complex example would be `foo.my-revision.polonius.stderr`.
+
+There are several [headers](headers.md) which will change how compiletest will
+check for output files:
+
+* `stderr-per-bitwidth` — checks separate output files based on the target
+  pointer width. Consider using the `normalize-stderr` header instead (see
+  [Normalization](#normalization)).
+* `dont-check-compiler-stderr` — Ignores stderr from the compiler.
+* `dont-check-compiler-stdout` — Ignores stdout from the compiler.
+
+UI tests run with with `-Zdeduplicate-diagnostics=no` flag which disables
+rustc's built-in diagnostic deduplication mechanism.
+This means you may see some duplicate messages in the output.
+This helps illuminate situations where duplicate diagnostics are being
+generated.
+
+### Normalization
+
+The compiler output is normalized to eliminate output difference between
+platforms, mainly about filenames.
+
+Compiletest makes the following replacements on the compiler output:
+
+- The directory where the test is defined is replaced with `$DIR`.
+  Example: `/path/to/rust/src/test/ui/error-codes`
+- The directory to the standard library source is replaced with `$SRC_DIR`.
+  Example: `/path/to/rust/library`
+- Line and column numbers for paths in `$SRC_DIR` are replaced with `LL:COL`.
+  This helps ensure that changes to the layout of the standard library do not
+  cause widespread changes to the `.stderr` files.
+  Example: `$SRC_DIR/alloc/src/sync.rs:53:46`
+- The base directory where the test's output goes is replaced with `$TEST_BUILD_DIR`.
+  This only comes up in a few rare circumstances.
+  Example: `/path/to/rust/build/x86_64-unknown-linux-gnu/test/ui`
+- Tabs are replaced with `\t`.
+- Backslashes (`\`) are converted to forward slashes (`/`) within paths (using
+  a heuristic). This helps normalize differences with Windows-style paths.
+- CRLF newlines are converted to LF.
+- Error line annotations like `//~ ERROR some message` are removed.
+- Various v0 and legacy symbol hashes are replaced with placeholders like
+  `[HASH]` or `<SYMBOL_HASH>`.
+
+Additionally, the compiler is run with the `-Z ui-testing` flag which causes
+the compiler itself to apply some changes to the diagnostic output to make it
+more suitable for UI testing.
+For example, it will anonymize line numbers in the output (line numbers
+prefixing each source line are replaced with `LL`).
+In extremely rare situations, this mode can be disabled with the header
+command `// compile-flags: -Z ui-testing=no`.
+
+Note: The line and column numbers for `-->` lines pointing to the test are
+*not* normalized, and left as-is. This ensures that the compiler continues
+to point to the correct location, and keeps the stderr files readable.
+Ideally all line/column information would be retained, but small changes to
+the source causes large diffs, and more frequent merge conflicts and test
+errors.
+
+Sometimes these built-in normalizations are not enough. In such cases, you
+may provide custom normalization rules using the header commands, e.g.
+
+```rust,ignore
+// normalize-stdout-test: "foo" -> "bar"
+// normalize-stderr-32bit: "fn\(\) \(32 bits\)" -> "fn\(\) \($$PTR bits\)"
+// normalize-stderr-64bit: "fn\(\) \(64 bits\)" -> "fn\(\) \($$PTR bits\)"
+```
+
+This tells the test, on 32-bit platforms, whenever the compiler writes
+`fn() (32 bits)` to stderr, it should be normalized to read `fn() ($PTR bits)`
+instead. Similar for 64-bit. The replacement is performed by regexes using
+default regex flavor provided by `regex` crate.
+
+The corresponding reference file will use the normalized output to test both
+32-bit and 64-bit platforms:
+
+```text
+...
+   |
+   = note: source type: fn() ($PTR bits)
+   = note: target type: u16 (16 bits)
+...
+```
+
+Please see [`ui/transmute/main.rs`][mrs] and [`main.stderr`] for a
+concrete usage example.
+
+[mrs]: https://github.com/rust-lang/rust/blob/master/src/test/ui/transmute/main.rs
+[`main.stderr`]: https://github.com/rust-lang/rust/blob/master/src/test/ui/transmute/main.stderr
+
+Besides `normalize-stderr-32bit` and `-64bit`, one may use any target
+information or stage supported by [`ignore-X`](headers.md#ignoring-tests)
+here as well (e.g. `normalize-stderr-windows` or simply
+`normalize-stderr-test` for unconditional replacement).
+
+
+## Error annotations
+
+Error annotations specify the errors that the compiler is expected to emit.
+They are "attached" to the line in source where the error is located.
+
+```rust,ignore
+fn main() {
+    boom  //~ ERROR cannot find value `boom` in this scope [E0425]
+}
+```
+
+Although UI tests have a `.stderr` file which contains the entire compiler output,
+UI tests require that errors are also annotated within the source.
+This redundancy helps avoid mistakes since the `.stderr` files are usually
+auto-generated.
+It also helps to directly see where the error spans are expected to point to
+by looking at one file instead of having to compare the `.stderr` file with
+the source.
+Finally, they ensure that no additional unexpected errors are generated.
+
+They have several forms, but generally are a comment with the diagnostic
+level (such as `ERROR`) and a substring of the expected error output.
+You don't have to write out the entire message, just make sure to include the
+important part of the message to make it self-documenting.
+
+The error annotation needs to match with the line of the diagnostic.
+There are several ways to match the message with the line (see the examples below):
+
+* `~`: Associates the error level and message with the current line
+* `~^`: Associates the error level and message with the previous error
+  annotation line.
+  Each caret (`^`) that you add adds a line to this, so `~^^^` is three lines
+  above the error annotation line.
+* `~|`: Associates the error level and message with the same line as the
+  previous comment.
+  This is more convenient than using multiple carets when there are multiple
+  messages associated with the same line.
+
+### Error annotation examples
+
+Here are examples of error annotations on different lines of UI test
+source.
+
+#### Positioned on error line
+
+Use the `//~ ERROR` idiom:
+
+```rust,ignore
+fn main() {
+    let x = (1, 2, 3);
+    match x {
+        (_a, _x @ ..) => {} //~ ERROR `_x @` is not allowed in a tuple
+        _ => {}
+    }
+}
+```
+
+#### Positioned below error line
+
+Use the `//~^` idiom with number of carets in the string to indicate the
+number of lines above.
+In the example below, the error line is four lines above the error annotation
+line so four carets are included in the annotation.
+
+```rust,ignore
+fn main() {
+    let x = (1, 2, 3);
+    match x {
+        (_a, _x @ ..) => {}  // <- the error is on this line
+        _ => {}
+    }
+}
+//~^^^^ ERROR `_x @` is not allowed in a tuple
+```
+
+#### Use same error line as defined on error annotation line above
+
+Use the `//~|` idiom to define the same error line as the error annotation
+line above:
+
+```rust,ignore
+struct Binder(i32, i32, i32);
+
+fn main() {
+    let x = Binder(1, 2, 3);
+    match x {
+        Binder(_a, _x @ ..) => {}  // <- the error is on this line
+        _ => {}
+    }
+}
+//~^^^^ ERROR `_x @` is not allowed in a tuple struct
+//~| ERROR this pattern has 1 field, but the corresponding tuple struct has 3 fields [E0023]
+```
+
+### `error-pattern`
+
+The `error-pattern` [header](headers.md) can be used for
+messages that don't have a specific span.
+
+Let's think about this test:
+
+```rust,ignore
+fn main() {
+    let a: *const [_] = &[1, 2, 3];
+    unsafe {
+        let _b = (*a)[3];
+    }
+}
+```
+
+We want to ensure this shows "index out of bounds" but we cannot use the
+`ERROR` annotation since the error doesn't have any span.
+Then it's time to use the `error-pattern` header:
+
+```rust,ignore
+// error-pattern: index out of bounds
+fn main() {
+    let a: *const [_] = &[1, 2, 3];
+    unsafe {
+        let _b = (*a)[3];
+    }
+}
+```
+
+But for strict testing, try to use the `ERROR` annotation as much as possible.
+
+### Error levels
+
+The error levels that you can have are:
+
+1. `ERROR`
+2. `WARN` or `WARNING`
+3. `NOTE`
+4. `HELP` and `SUGGESTION`
+
+You are allowed to not include a level, but you should include it at least for
+the primary message.
+
+The `SUGGESTION` level is used for specifying what the expected replacement
+text should be for a diagnostic suggestion.
+
+UI tests use the `-A unused` flag by default to ignore all unused warnings, as
+unused warnings are usually not the focus of a test.
+However, simple code samples often have unused warnings.
+If the test is specifically testing an unused warning, just add the
+appropriate `#![warn(unused)]` attribute as needed.
+
+### cfg revisions
+
+When using [revisions](compiletest.md#revisions), different messages can be
+conditionally checked based on the current revision.
+This is done by placing the revision cfg name in brackets like this:
+
+```rust,ignore
+// edition:2018
+// revisions: mir thir
+// [thir]compile-flags: -Z thir-unsafeck
+
+async unsafe fn f() {}
+
+async fn g() {
+    f(); //~ ERROR call to unsafe function is unsafe
+}
+
+fn main() {
+    f(); //[mir]~ ERROR call to unsafe function is unsafe
+}
+```
+
+In this example, the second error message is only emitted in the `mir` revision.
+The `thir` revision only emits the first error.
+
+If the cfg causes the compiler to emit different output, then a test can have
+multiple `.stderr` files for the different outputs.
+In the example above, there would be a `.mir.stderr` and `.thir.stderr` file
+with the different outputs of the different revisions.
+
+
+## Controlling pass/fail expectations
+
+By default, a UI test is expected to **generate a compile error** because most
+of the tests are checking for invalid input and error diagnostics.
+However, you can also make UI tests where compilation is expected to succeed,
+and you can even run the resulting program.
+Just add one of the following [header commands](headers.md):
+
+* Pass headers:
+  * `// check-pass` — compilation should succeed but skip codegen
+    (which is expensive and isn't supposed to fail in most cases).
+  * `// build-pass` — compilation and linking should succeed but do
+    not run the resulting binary.
+  * `// run-pass` — compilation should succeed and running the resulting
+    binary should also succeed.
+* Fail headers:
+  * `// check-fail` — compilation should fail (the codegen phase is skipped).
+    This is the default for UI tests.
+  * `// build-fail` — compilation should fail during the codegen phase.
+    This will run `rustc` twice, once to verify that it compiles successfully
+    without the codegen phase, then a second time the full compile should
+    fail.
+  * `// run-fail` — compilation should succeed, but running the resulting
+    binary should fail.
+
+For `run-pass` and `run-fail` tests, by default the output of the program
+itself is not checked.
+If you want to check the output of running the program, include the
+`check-run-results` header.
+This will check for a `.run.stderr` and `.run.stdout` files to compare
+against the actual output of the program.
+
+Tests with the `*-pass` headers can be overridden with the `--pass`
+command-line option:
+
+```sh
+./x.py test src/test/ui --pass check
+```
+
+The `--pass` option only affects UI tests.
+Using `--pass check` can run the UI test suite much faster (roughly twice as
+fast on my system), though obviously not exercising as much.
+
+The `ignore-pass` header can be used to ignore the `--pass` CLI flag if the
+test won't work properly with that override.
+
+
+## Known bugs
+
+The `known-bug` header may be used for tests that demonstrate a known bug that
+has not yet been fixed.
+Adding tests for known bugs is helpful for several reasons, including:
+
+1. Maintaining a functional test that can be conveniently reused when the bug is fixed.
+2. Providing a sentinel that will fail if the bug is incidentally fixed.
+   This can alert the developer so they know that the associated issue has
+   been fixed and can possibly be closed.
+
+Do not include [error annotations](#error-annotations) in a test with `known-bug`.
+The test should still include other normal headers and stdout/stderr files.
+
+
+## Test organization
+
+When deciding where to place a test file, please try to find a subdirectory
+that best matches what you are trying to exercise.
+Do your best to keep things organized.
+Admittedly it can be difficult as some tests can overlap different categories,
+and the existing layout may not fit well.
+
+For regression tests – basically, some random snippet of code that came in
+from the internet – we often name the test after the issue plus a short
+description.
+Ideally, the test should be added to a directory that helps identify what
+piece of code is being tested here (e.g.,
+`src/test/ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.rs`)
+
+When writing a new feature, **create a subdirectory to store your tests**.
+For example, if you are implementing RFC 1234 ("Widgets"), then it might make
+sense to put the tests in a directory like `src/test/ui/rfc1234-widgets/`.
+
+In other cases, there may already be a suitable directory. (The proper
+directory structure to use is actually an area of active debate.)
+
+Over time, the [`src/test/ui`] directory has grown very fast.
+There is a check in [tidy](intro.md#tidy) that will ensure none of the
+subdirectories has more than 1000 entries.
+Having too many files causes problems because it isn't editor/IDE friendly and
+the GitHub UI won't show more than 1000 entries.
+However, since `src/test/ui` (UI test root directory) and `src/test/ui/issues`
+directories have more than 1000 entries, we set a different limit for those
+directories.
+So, please avoid putting a new test there and try to find a more relevant
+place.
+
+For example, if your test is related to closures, you should put it in
+`src/test/ui/closures`.
+If you're not sure where is the best place, it's still okay to add to
+`src/test/ui/issues/`.
+When you reach the limit, you could increase it by tweaking [here][ui test
+tidy].
+
+[ui test tidy]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/src/ui_tests.rs
+
+
+## Rustfix tests
+
+UI tests can validate that diagnostic suggestions apply correctly
+and that the resulting changes compile correctly.
+This can be done with the `run-rustfix` header:
+
+```rust,ignore
+// run-rustfix
+// check-pass
+#![crate_type = "lib"]
+
+pub struct not_camel_case {}
+//~^ WARN `not_camel_case` should have an upper camel case name
+//~| HELP convert the identifier to upper camel case
+//~| SUGGESTION NotCamelCase
+```
+
+Rustfix tests should have a file with the `.fixed` extension which contains
+the source file after the suggestion has been applied.
+
+When the test is run, compiletest first checks that the correct
+lint/warning is generated.
+Then, it applies the suggestion and compares against `.fixed` (they must match).
+Finally, the fixed source is compiled, and this compilation is required to succeed.
+
+Usually when creating a rustfix test you will generate the `.fixed` file
+automatically with the `x.py test --bless` option.
+
+The `run-rustfix` header will cause *all* suggestions to be applied, even
+if they are not [`MachineApplicable`](../diagnostics.md#suggestions).
+If this is a problem, then you can instead use the `rustfix-only-machine-applicable`
+header.
+This should be used if there is a mixture of different suggestion levels, and
+some of the non-machine-applicable ones do not apply cleanly.
+
+
+## Compare modes
+
+[Compare modes](compiletest.md#compare-modes) can be used to run all tests
+with different flags from what they are normally compiled with.
+In some cases, this might result in different output from the compiler.
+To support this, different output files can be saved which contain the
+output based on the compare mode.
+
+For example, when using the Polonius mode, a test `foo.rs` will
+first look for expected output in `foo.polonius.stderr`, falling back to the usual
+`foo.stderr` if not found.
+This is useful as different modes can sometimes result in different
+diagnostics and behavior.
+This can help track which tests have differences between the modes, and to
+visually inspect those diagnostic differences.
+
+If in the rare case you encounter a test that has different behavior, you can
+run something like the following to generate the alternate stderr file:
+
+```sh
+./x.py test src/test/ui --compare-mode=polonius --bless
+```
+
+Currently none of the compare modes are checked in CI for UI tests.
diff --git a/src/doc/rustc-dev-guide/src/the-parser.md b/src/doc/rustc-dev-guide/src/the-parser.md
new file mode 100644
index 000000000..ff43220c1
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/the-parser.md
@@ -0,0 +1,70 @@
+# Lexing and Parsing
+
+As of <!-- date: 2021-01 --> January 2021, the lexer and parser are undergoing
+refactoring to allow extracting them into libraries.
+
+The very first thing the compiler does is take the program (in Unicode
+characters) and turn it into something the compiler can work with more
+conveniently than strings. This happens in two stages: Lexing and Parsing.
+
+Lexing takes strings and turns them into streams of [tokens]. For example,
+`a.b + c` would be turned into the tokens `a`, `.`, `b`, `+`, and `c`.
+The lexer lives in [`rustc_lexer`][lexer].
+
+[tokens]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/token/index.html
+[lexer]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/index.html
+
+Parsing then takes streams of tokens and turns them into a structured
+form which is easier for the compiler to work with, usually called an [*Abstract
+Syntax Tree*][ast] (AST). An AST mirrors the structure of a Rust program in memory,
+using a `Span` to link a particular AST node back to its source text.
+
+The AST is defined in [`rustc_ast`][rustc_ast], along with some definitions for
+tokens and token streams, data structures/traits for mutating ASTs, and shared
+definitions for other AST-related parts of the compiler (like the lexer and
+macro-expansion).
+
+The parser is defined in [`rustc_parse`][rustc_parse], along with a
+high-level interface to the lexer and some validation routines that run after
+macro expansion. In particular, the [`rustc_parse::parser`][parser] contains
+the parser implementation.
+
+The main entrypoint to the parser is via the various `parse_*` functions and others in the
+[parser crate][parser_lib]. They let you do things like turn a [`SourceFile`][sourcefile]
+(e.g. the source in a single file) into a token stream, create a parser from
+the token stream, and then execute the parser to get a `Crate` (the root AST
+node).
+
+To minimise the amount of copying that is done, both the `StringReader` and
+`Parser` have lifetimes which bind them to the parent `ParseSess`. This contains
+all the information needed while parsing, as well as the `SourceMap` itself.
+
+Note that while parsing, we may encounter macro definitions or invocations. We
+set these aside to be expanded (see [this chapter](./macro-expansion.md)).
+Expansion may itself require parsing the output of the macro, which may reveal
+more macros to be expanded, and so on.
+
+## More on Lexical Analysis
+
+Code for lexical analysis is split between two crates:
+
+- `rustc_lexer` crate is responsible for breaking a `&str` into chunks
+  constituting tokens. Although it is popular to implement lexers as generated
+  finite state machines, the lexer in `rustc_lexer` is hand-written.
+
+- [`StringReader`] from [`rustc_ast`][rustc_ast] integrates `rustc_lexer` with `rustc`
+  specific data structures. Specifically, it adds `Span` information to tokens
+  returned by `rustc_lexer` and interns identifiers.
+
+[rustc_ast]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/index.html
+[rustc_errors]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/index.html
+[ast]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[`SourceMap`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/source_map/struct.SourceMap.html
+[ast module]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/index.html
+[rustc_parse]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
+[parser_lib]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
+[parser]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/parser/index.html
+[`Parser`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/parse/parser/struct.Parser.html
+[`StringReader`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.StringReader.html
+[visit module]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/visit/index.html
+[sourcefile]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.SourceFile.html
diff --git a/src/doc/rustc-dev-guide/src/thir.md b/src/doc/rustc-dev-guide/src/thir.md
new file mode 100644
index 000000000..4f8e6512c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/thir.md
@@ -0,0 +1,223 @@
+# The THIR
+
+<!-- toc -->
+
+The THIR ("Typed High-Level Intermediate Representation"), previously called HAIR for
+"High-Level Abstract IR", is another IR used by rustc that is generated after
+[type checking]. It is (as of <!-- date: 2022-04 --> April 2022) only used for
+[MIR construction] and [exhaustiveness checking]. There is also
+[an experimental unsafety checker][thir-unsafeck] that operates on the THIR as a replacement for
+the current MIR unsafety checker, and can be used instead of the MIR unsafety checker by passing
+the `-Z thir-unsafeck` flag to `rustc`.
+
+[type checking]: ./type-checking.md
+[MIR construction]: ./mir/construction.md
+[exhaustiveness checking]: ./pat-exhaustive-checking.md
+[thir-unsafeck]: https://github.com/rust-lang/compiler-team/issues/402
+
+As the name might suggest, the THIR is a lowered version of the [HIR] where all
+the types have been filled in, which is possible after type checking has completed.
+But it has some other interesting features that distinguish it from the HIR:
+
+- Like the MIR, the THIR only represents bodies, i.e. "executable code"; this includes
+  function bodies, but also `const` initializers, for example. Specifically, all [body owners] have
+  THIR created. Consequently, the THIR has no representation for items like `struct`s or `trait`s.
+
+- Each body of THIR is only stored temporarily and is dropped as soon as it's no longer
+  needed, as opposed to being stored until the end of the compilation process (which
+  is what is done with the HIR).
+
+- Besides making the types of all nodes available, the THIR also has additional
+  desugaring compared to the HIR. For example, automatic references and dereferences
+  are made explicit, and method calls and overloaded operators are converted into
+  plain function calls. Destruction scopes are also made explicit.
+
+- Statements, expressions, and match arms are stored separately. For example, statements in the
+  `stmts` array reference expressions by their index (represented as a [`ExprId`]) in the `exprs`
+  array.
+
+[HIR]: ./hir.md
+[`ExprId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/thir/struct.ExprId.html
+[body owners]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/enum.BodyOwnerKind.html
+
+The THIR lives in [`rustc_mir_build::thir`][thir-docs]. To construct a [`thir::Expr`],
+you can use the [`thir_body`] function, passing in the memory arena where the THIR
+will be allocated. Dropping this arena will result in the THIR being destroyed,
+which is useful to keep peak memory in check. Having a THIR representation of
+all bodies of a crate in memory at the same time would be very heavy.
+
+You can get a debug representation of the THIR by passing the `-Zunpretty=thir-tree` flag
+to `rustc`. Here is how a function with just the statement `let x = 1 + 2;` gets represented in
+THIR:
+```rust
+Thir {
+    // no match arms
+    arms: [],
+    exprs: [
+        // expression 0, a literal with a value of 1
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:13: 2:14 (#0),
+            kind: Literal {
+                literal: Const {
+                    ty: i32,
+                    val: Value(Scalar(0x00000001)),
+                },
+                user_ty: None,
+                const_id: None,
+            },
+        },
+        // expression 1, scope surronding literal 1
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:13: 2:14 (#0),
+            kind: Scope {
+                region_scope: Node(1),
+                lint_level: Explicit(HirId {
+                    owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                    local_id: 1,
+                }),
+                // reference to expression 0 above
+                value: e0,
+            },
+        },
+        // expression 2, literal 2
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:17: 2:18 (#0),
+            kind: Literal {
+                literal: Const {
+                    ty: i32,
+                    val: Value(Scalar(0x00000002)),
+                },
+                user_ty: None,
+                const_id: None,
+            },
+        },
+        // expression 3, scope surrounding literal 2
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:17: 2:18 (#0),
+            kind: Scope {
+                region_scope: Node(2),
+                lint_level: Explicit(HirId {
+                    owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                    local_id: 2,
+                }),
+                // reference to expression 2 above
+                value: e2,
+            },
+        },
+        // expression 4, represents 1 + 2
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:13: 2:18 (#0),
+            kind: Binary {
+                op: Add,
+                // references to scopes surronding literals above
+                lhs: e1,
+                rhs: e3,
+            },
+        },
+        // expression 5, scope surronding expression 4
+        Expr {
+            ty: i32,
+            temp_lifetime: Some(Node(6)),
+            span: oneplustwo.rs:2:13: 2:18 (#0),
+            kind: Scope {
+                region_scope: Node(3),
+                lint_level: Explicit(HirId {
+                    owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                    local_id: 3,
+                }),
+                value: e4,
+            },
+        },
+        // expression 6, block around statement
+        Expr {
+            ty: (),
+            temp_lifetime: Some(Node(8)),
+            span: oneplustwo.rs:1:11: 3:2 (#0),
+            kind: Block {
+                body: Block {
+                    targeted_by_break: false,
+                    region_scope: Node(7),
+                    opt_destruction_scope: None,
+                    span: oneplustwo.rs:1:11: 3:2 (#0),
+                    // reference to statement 0 below
+                    stmts: [ s0 ],
+                    expr: None,
+                    safety_mode: Safe,
+                },
+            },
+        },
+        // expression 7, scope around block in expression 6
+        Expr {
+            ty: (),
+            temp_lifetime: Some(
+                Node(8),
+            ),
+            span: oneplustwo.rs:1:11: 3:2 (#0),
+            kind: Scope {
+                region_scope: Node(8),
+                lint_level: Explicit(HirId {
+                    owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                    local_id: 8,
+                }),
+                value: e6,
+            },
+        },
+        // destruction scope around expression 7
+        Expr {
+            ty: (),
+            temp_lifetime: Some(Node(8)),
+            span: oneplustwo.rs:1:11: 3:2 (#0),
+            kind: Scope {
+                region_scope: Destruction(8),
+                lint_level: Inherited,
+                value: e7,
+            },
+        },
+    ],
+    stmts: [
+        // let statement
+        Stmt {
+            kind: Let {
+                remainder_scope: Remainder { block: 7, first_statement_index: 0},
+                init_scope: Node(6),
+                pattern: Pat {
+                    ty: i32,
+                    span: oneplustwo.rs:2:9: 2:10 (#0),
+                    kind: Binding {
+                        mutability: Not,
+                        name: "x",
+                        mode: ByValue,
+                        var: HirId {
+                            owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                            local_id: 5,
+                        },
+                        ty: i32,
+                        subpattern: None,
+                        is_primary: true,
+                    },
+                },
+                initializer: Some(e5),
+                lint_level: Explicit(HirId {
+                    owner: DefId(0:3 ~ oneplustwo[6ccc]::main),
+                    local_id: 4,
+                }),
+            },
+            opt_destruction_scope: Some(Destruction(6)),
+        },
+    ],
+}
+```
+
+[thir-docs]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_mir_build/thir/index.html
+[`thir::Expr`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/thir/struct.Expr.html
+[`thir_body`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html#method.thir_body
diff --git a/src/doc/rustc-dev-guide/src/tracing.md b/src/doc/rustc-dev-guide/src/tracing.md
new file mode 100644
index 000000000..0bba73f74
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/tracing.md
@@ -0,0 +1,228 @@
+# Using tracing to debug the compiler
+
+<!-- toc -->
+
+The compiler has a lot of [`debug!`] (or `trace!`) calls, which print out logging information
+at many points. These are very useful to at least narrow down the location of
+a bug if not to find it entirely, or just to orient yourself as to why the
+compiler is doing a particular thing.
+
+[`debug!`]: https://docs.rs/tracing/0.1/tracing/macro.debug.html
+
+To see the logs, you need to set the `RUSTC_LOG` environment variable to your
+log filter. The full syntax of the log filters can be found in the [rustdoc
+of `tracing-subscriber`](https://docs.rs/tracing-subscriber/0.2.24/tracing_subscriber/filter/struct.EnvFilter.html#directives).
+
+## Function level filters
+
+Lots of functions in rustc are annotated with
+
+```
+#[instrument(level = "debug", skip(self))]
+fn foo(&self, bar: Type) {}
+```
+
+which allows you to use
+
+```
+RUSTC_LOG=[foo]
+```
+
+to do the following all at once
+
+* log all function calls to `foo`
+* log the arguments (except for those in the `skip` list)
+* log everything (from anywhere else in the compiler) until the function returns
+
+### I don't want everything
+
+Depending on the scope of the function, you may not want to log everything in its body.
+As an example: the `do_mir_borrowck` function will dump hundreds of lines even for trivial
+code being borrowchecked.
+
+Since you can combine all filters, you can add a crate/module path, e.g.
+
+```
+RUSTC_LOG=rustc_borrowck[do_mir_borrowck]
+```
+
+### I don't want all calls
+
+If you are compiling libcore, you likely don't want *all* borrowck dumps, but only one
+for a specific function. You can filter function calls by their arguments by regexing them.
+
+```
+RUSTC_LOG=[do_mir_borrowck{id=\.\*from_utf8_unchecked\.\*}]
+```
+
+will only give you the logs of borrowchecking `from_utf8_unchecked`. Note that you will
+still get a short message per ignored `do_mir_borrowck`, but none of the things inside those
+calls. This helps you in looking through the calls that are happening and helps you adjust
+your regex if you mistyped it.
+
+## Query level filters
+
+Every [query](query.md) is automatically tagged with a logging span so that
+you can display all log messages during the execution of the query. For
+example, if you want to log everything during type checking:
+
+```
+RUSTC_LOG=[typeck]
+```
+
+The query arguments are included as a tracing field which means that you can
+filter on the debug display of the arguments. For example, the `typeck` query
+has an argument `key: LocalDefId` of what is being checked. You can use a
+regex to match on that `LocalDefId` to log type checking for a specific
+function:
+
+```
+RUSTC_LOG=[typeck{key=.*name_of_item.*}]
+```
+
+Different queries have different arguments. You can find a list of queries and
+their arguments in
+[`rustc_middle/src/query/mod.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/query/mod.rs#L18).
+
+## Broad module level filters
+
+You can also use filters similar to the `log` crate's filters, which will enable
+everything within a specific module. This is often too verbose and too unstructured,
+so it is recommended to use function level filters.
+
+Your log filter can be just `debug` to get all `debug!` output and
+higher (e.g., it will also include `info!`), or `path::to::module` to get *all*
+output (which will include `trace!`) from a particular module, or
+`path::to::module=debug` to get `debug!` output and higher from a particular
+module.
+
+For example, to get the `debug!` output and higher for a specific module, you
+can run the compiler with `RUSTC_LOG=path::to::module=debug rustc my-file.rs`.
+All `debug!` output will then appear in standard error.
+
+Note that you can use a partial path and the filter will still work. For
+example, if you want to see `info!` output from only
+`rustdoc::passes::collect_intra_doc_links`, you could use
+`RUSTDOC_LOG=rustdoc::passes::collect_intra_doc_links=info` *or* you could use
+`RUSTDOC_LOG=rustdoc::passes::collect_intra=info`.
+
+If you are developing rustdoc, use `RUSTDOC_LOG` instead. If you are developing
+Miri, use `MIRI_LOG` instead. You get the idea :)
+
+See the [`tracing`] crate's docs, and specifically the docs for [`debug!`] to
+see the full syntax you can use. (Note: unlike the compiler, the [`tracing`]
+crate and its examples use the `RUST_LOG` environment variable. rustc, rustdoc,
+and other tools set custom environment variables.)
+
+**Note that unless you use a very strict filter, the logger will emit a lot of
+output, so use the most specific module(s) you can (comma-separated if
+multiple)**. It's typically a good idea to pipe standard error to a file and
+look at the log output with a text editor.
+
+So, to put it together:
+
+```bash
+# This puts the output of all debug calls in `rustc_middle/src/traits` into
+# standard error, which might fill your console backscroll.
+$ RUSTC_LOG=rustc_middle::traits=debug rustc +stage1 my-file.rs
+
+# This puts the output of all debug calls in `rustc_middle/src/traits` in
+# `traits-log`, so you can then see it with a text editor.
+$ RUSTC_LOG=rustc_middle::traits=debug rustc +stage1 my-file.rs 2>traits-log
+
+# Not recommended! This will show the output of all `debug!` calls
+# in the Rust compiler, and there are a *lot* of them, so it will be
+# hard to find anything.
+$ RUSTC_LOG=debug rustc +stage1 my-file.rs 2>all-log
+
+# This will show the output of all `info!` calls in `rustc_codegen_ssa`.
+#
+# There's an `info!` statement in `codegen_instance` that outputs
+# every function that is codegen'd. This is useful to find out
+# which function triggers an LLVM assertion, and this is an `info!`
+# log rather than a `debug!` log so it will work on the official
+# compilers.
+$ RUSTC_LOG=rustc_codegen_ssa=info rustc +stage1 my-file.rs
+
+# This will show the output of all `info!` calls made by rustdoc
+# or any rustc library it calls.
+$ RUSTDOC_LOG=info rustdoc +stage1 my-file.rs
+
+# This will only show `debug!` calls made by rustdoc directly,
+# not any `rustc*` crate.
+$ RUSTDOC_LOG=rustdoc=debug rustdoc +stage1 my-file.rs
+```
+
+## Log colors
+
+By default, rustc (and other tools, like rustdoc and Miri) will be smart about
+when to use ANSI colors in the log output. If they are outputting to a terminal,
+they will use colors, and if they are outputting to a file or being piped
+somewhere else, they will not. However, it's hard to read log output in your
+terminal unless you have a very strict filter, so you may want to pipe the
+output to a pager like `less`. But then there won't be any colors, which makes
+it hard to pick out what you're looking for!
+
+You can override whether to have colors in log output with the `RUSTC_LOG_COLOR`
+environment variable (or `RUSTDOC_LOG_COLOR` for rustdoc, or `MIRI_LOG_COLOR`
+for Miri, etc.). There are three options: `auto` (the default), `always`, and
+`never`. So, if you want to enable colors when piping to `less`, use something
+similar to this command:
+
+```bash
+# The `-R` switch tells less to print ANSI colors without escaping them.
+$ RUSTC_LOG=debug RUSTC_LOG_COLOR=always rustc +stage1 ... | less -R
+```
+
+Note that `MIRI_LOG_COLOR` will only color logs that come from Miri, not logs
+from rustc functions that Miri calls. Use `RUSTC_LOG_COLOR` to color logs from
+rustc.
+
+## How to keep or remove `debug!` and `trace!` calls from the resulting binary
+
+While calls to `error!`, `warn!` and `info!` are included in every build of the compiler,
+calls to `debug!` and `trace!` are only included in the program if
+`debug-logging=true` is turned on in config.toml (it is
+turned off by default), so if you don't see `DEBUG` logs, especially
+if you run the compiler with `RUSTC_LOG=rustc rustc some.rs` and only see
+`INFO` logs, make sure that `debug-logging=true` is turned on in your
+config.toml.
+
+## Logging etiquette and conventions
+
+Because calls to `debug!` are removed by default, in most cases, don't worry
+about the performance of adding "unnecessary" calls to `debug!` and leaving them in code you
+commit - they won't slow down the performance of what we ship.
+
+That said, there can also be excessive tracing calls, especially
+when they are redundant with other calls nearby or in functions called from
+here. There is no perfect balance to hit here, and is left to the reviewer's
+discretion to decide whether to let you leave `debug!` statements in or whether to ask
+you to remove them before merging.
+
+It may be preferable to use `trace!` over `debug!` for very noisy logs.
+
+A loosely followed convention is to use `#[instrument(level = "debug")]`
+([also see the attribute's documentation](https://docs.rs/tracing-attributes/0.1.17/tracing_attributes/attr.instrument.html))
+in favour of `debug!("foo(...)")` at the start of a function `foo`.
+Within functions, prefer `debug!(?variable.field)` over `debug!("xyz = {:?}", variable.field)`
+and `debug!(bar = ?var.method(arg))` over `debug!("bar = {:?}", var.method(arg))`.
+The documentation for this syntax can be found [here](https://docs.rs/tracing/0.1.28/tracing/#recording-fields).
+
+One thing to be **careful** of is **expensive** operations in logs.
+
+If in the module `rustc::foo` you have a statement
+
+```Rust
+debug!(x = ?random_operation(tcx));
+```
+
+Then if someone runs a debug `rustc` with `RUSTC_LOG=rustc::foo`, then
+`random_operation()` will run. `RUSTC_LOG` filters that do not enable this
+debug statement will not execute `random_operation`.
+
+This means that you should not put anything too expensive or likely to crash
+there - that would annoy anyone who wants to use logging for that module.
+No-one will know it until someone tries to use logging to find *another* bug.
+
+[`tracing`]: https://docs.rs/tracing
diff --git a/src/doc/rustc-dev-guide/src/traits/caching.md b/src/doc/rustc-dev-guide/src/traits/caching.md
new file mode 100644
index 000000000..54bd0704a
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/caching.md
@@ -0,0 +1,67 @@
+# Caching and subtle considerations therewith
+
+In general, we attempt to cache the results of trait selection.  This
+is a somewhat complex process. Part of the reason for this is that we
+want to be able to cache results even when all the types in the trait
+reference are not fully known. In that case, it may happen that the
+trait selection process is also influencing type variables, so we have
+to be able to not only cache the *result* of the selection process,
+but *replay* its effects on the type variables.
+
+## An example
+
+The high-level idea of how the cache works is that we first replace
+all unbound inference variables with placeholder versions. Therefore,
+if we had a trait reference `usize : Foo<$t>`, where `$t` is an unbound
+inference variable, we might replace it with `usize : Foo<$0>`, where
+`$0` is a placeholder type. We would then look this up in the cache.
+
+If we found a hit, the hit would tell us the immediate next step to
+take in the selection process (e.g. apply impl #22, or apply where
+clause `X : Foo<Y>`).
+
+On the other hand, if there is no hit, we need to go through the [selection
+process] from scratch. Suppose, we come to the conclusion that the only
+possible impl is this one, with def-id 22:
+
+[selection process]: ./resolution.html#selection
+
+```rust,ignore
+impl Foo<isize> for usize { ... } // Impl #22
+```
+
+We would then record in the cache `usize : Foo<$0> => ImplCandidate(22)`. Next
+we would [confirm] `ImplCandidate(22)`, which would (as a side-effect) unify
+`$t` with `isize`.
+
+[confirm]: ./resolution.html#confirmation
+
+Now, at some later time, we might come along and see a `usize :
+Foo<$u>`. When replaced with a placeholder, this would yield `usize : Foo<$0>`, just as
+before, and hence the cache lookup would succeed, yielding
+`ImplCandidate(22)`. We would confirm `ImplCandidate(22)` which would
+(as a side-effect) unify `$u` with `isize`.
+
+## Where clauses and the local vs global cache
+
+One subtle interaction is that the results of trait lookup will vary
+depending on what where clauses are in scope. Therefore, we actually
+have *two* caches, a local and a global cache. The local cache is
+attached to the [`ParamEnv`], and the global cache attached to the
+[`tcx`]. We use the local cache whenever the result might depend on the
+where clauses that are in scope. The determination of which cache to
+use is done by the method `pick_candidate_cache` in `select.rs`. At
+the moment, we use a very simple, conservative rule: if there are any
+where-clauses in scope, then we use the local cache.  We used to try
+and draw finer-grained distinctions, but that led to a series of
+annoying and weird bugs like [#22019] and [#18290]. This simple rule seems
+to be pretty clearly safe and also still retains a very high hit rate
+(~95% when compiling rustc).
+
+**TODO**: it looks like `pick_candidate_cache` no longer exists. In
+general, is this section still accurate at all?
+
+[`ParamEnv`]: ../param_env.html
+[`tcx`]: ../ty.html
+[#18290]: https://github.com/rust-lang/rust/issues/18290
+[#22019]: https://github.com/rust-lang/rust/issues/22019
diff --git a/src/doc/rustc-dev-guide/src/traits/canonical-queries.md b/src/doc/rustc-dev-guide/src/traits/canonical-queries.md
new file mode 100644
index 000000000..5ba450d4e
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/canonical-queries.md
@@ -0,0 +1,247 @@
+# Canonical queries
+
+The "start" of the trait system is the **canonical query** (these are
+both queries in the more general sense of the word – something you
+would like to know the answer to – and in the
+[rustc-specific sense](../query.html)).  The idea is that the type
+checker or other parts of the system, may in the course of doing their
+thing want to know whether some trait is implemented for some type
+(e.g., is `u32: Debug` true?). Or they may want to
+normalize some associated type.
+
+This section covers queries at a fairly high level of abstraction. The
+subsections look a bit more closely at how these ideas are implemented
+in rustc.
+
+## The traditional, interactive Prolog query
+
+In a traditional Prolog system, when you start a query, the solver
+will run off and start supplying you with every possible answer it can
+find. So given something like this:
+
+```text
+?- Vec<i32>: AsRef<?U>
+```
+
+The solver might answer:
+
+```text
+Vec<i32>: AsRef<[i32]>
+    continue? (y/n)
+```
+
+This `continue` bit is interesting. The idea in Prolog is that the
+solver is finding **all possible** instantiations of your query that
+are true. In this case, if we instantiate `?U = [i32]`, then the query
+is true (note that a traditional Prolog interface does not, directly,
+tell us a value for `?U`, but we can infer one by unifying the
+response with our original query – Rust's solver gives back a
+substitution instead). If we were to hit `y`, the solver might then
+give us another possible answer:
+
+```text
+Vec<i32>: AsRef<Vec<i32>>
+    continue? (y/n)
+```
+
+This answer derives from the fact that there is a reflexive impl
+(`impl<T> AsRef<T> for T`) for `AsRef`. If were to hit `y` again,
+then we might get back a negative response:
+
+```text
+no
+```
+
+Naturally, in some cases, there may be no possible answers, and hence
+the solver will just give me back `no` right away:
+
+```text
+?- Box<i32>: Copy
+    no
+```
+
+In some cases, there might be an infinite number of responses. So for
+example if I gave this query, and I kept hitting `y`, then the solver
+would never stop giving me back answers:
+
+```text
+?- Vec<?U>: Clone
+    Vec<i32>: Clone
+        continue? (y/n)
+    Vec<Box<i32>>: Clone
+        continue? (y/n)
+    Vec<Box<Box<i32>>>: Clone
+        continue? (y/n)
+    Vec<Box<Box<Box<i32>>>>: Clone
+        continue? (y/n)
+```
+
+As you can imagine, the solver will gleefully keep adding another
+layer of `Box` until we ask it to stop, or it runs out of memory.
+
+Another interesting thing is that queries might still have variables
+in them. For example:
+
+```text
+?- Rc<?T>: Clone
+```
+
+might produce the answer:
+
+```text
+Rc<?T>: Clone
+    continue? (y/n)
+```
+
+After all, `Rc<?T>` is true **no matter what type `?T` is**.
+
+<a name="query-response"></a>
+
+## A trait query in rustc
+
+The trait queries in rustc work somewhat differently. Instead of
+trying to enumerate **all possible** answers for you, they are looking
+for an **unambiguous** answer. In particular, when they tell you the
+value for a type variable, that means that this is the **only possible
+instantiation** that you could use, given the current set of impls and
+where-clauses, that would be provable.
+
+The response to a trait query in rustc is typically a
+`Result<QueryResult<T>, NoSolution>` (where the `T` will vary a bit
+depending on the query itself). The `Err(NoSolution)` case indicates
+that the query was false and had no answers (e.g., `Box<i32>: Copy`).
+Otherwise, the `QueryResult` gives back information about the possible answer(s)
+we did find. It consists of four parts:
+
+- **Certainty:** tells you how sure we are of this answer. It can have two
+  values:
+  - `Proven` means that the result is known to be true.
+    - This might be the result for trying to prove `Vec<i32>: Clone`,
+      say, or `Rc<?T>: Clone`.
+  - `Ambiguous` means that there were things we could not yet prove to
+    be either true *or* false, typically because more type information
+    was needed. (We'll see an example shortly.)
+    - This might be the result for trying to prove `Vec<?T>: Clone`.
+- **Var values:** Values for each of the unbound inference variables
+  (like `?T`) that appeared in your original query. (Remember that in Prolog,
+  we had to infer these.)
+  - As we'll see in the example below, we can get back var values even
+    for `Ambiguous` cases.
+- **Region constraints:** these are relations that must hold between
+  the lifetimes that you supplied as inputs. We'll ignore these here.
+- **Value:** The query result also comes with a value of type `T`. For
+  some specialized queries – like normalizing associated types –
+  this is used to carry back an extra result, but it's often just
+  `()`.
+
+### Examples
+
+Let's work through an example query to see what all the parts mean.
+Consider [the `Borrow` trait][borrow]. This trait has a number of
+impls; among them, there are these two (for clarity, I've written the
+`Sized` bounds explicitly):
+
+[borrow]: https://doc.rust-lang.org/std/borrow/trait.Borrow.html
+
+```rust,ignore
+impl<T> Borrow<T> for T where T: ?Sized
+impl<T> Borrow<[T]> for Vec<T> where T: Sized
+```
+
+**Example 1.** Imagine we are type-checking this (rather artificial)
+bit of code:
+
+```rust,ignore
+fn foo<A, B>(a: A, vec_b: Option<B>) where A: Borrow<B> { }
+
+fn main() {
+    let mut t: Vec<_> = vec![]; // Type: Vec<?T>
+    let mut u: Option<_> = None; // Type: Option<?U>
+    foo(t, u); // Example 1: requires `Vec<?T>: Borrow<?U>`
+    ...
+}
+```
+
+As the comments indicate, we first create two variables `t` and `u`;
+`t` is an empty vector and `u` is a `None` option. Both of these
+variables have unbound inference variables in their type: `?T`
+represents the elements in the vector `t` and `?U` represents the
+value stored in the option `u`.  Next, we invoke `foo`; comparing the
+signature of `foo` to its arguments, we wind up with `A = Vec<?T>` and
+`B = ?U`. Therefore, the where clause on `foo` requires that `Vec<?T>:
+Borrow<?U>`. This is thus our first example trait query.
+
+There are many possible solutions to the query `Vec<?T>: Borrow<?U>`;
+for example:
+
+- `?U = Vec<?T>`,
+- `?U = [?T]`,
+- `?T = u32, ?U = [u32]`
+- and so forth.
+
+Therefore, the result we get back would be as follows (I'm going to
+ignore region constraints and the "value"):
+
+- Certainty: `Ambiguous` – we're not sure yet if this holds
+- Var values: `[?T = ?T, ?U = ?U]` – we learned nothing about the values of
+  the variables
+
+In short, the query result says that it is too soon to say much about
+whether this trait is proven. During type-checking, this is not an
+immediate error: instead, the type checker would hold on to this
+requirement (`Vec<?T>: Borrow<?U>`) and wait. As we'll see in the next
+example, it may happen that `?T` and `?U` wind up constrained from
+other sources, in which case we can try the trait query again.
+
+**Example 2.** We can now extend our previous example a bit,
+and assign a value to `u`:
+
+```rust,ignore
+fn foo<A, B>(a: A, vec_b: Option<B>) where A: Borrow<B> { }
+
+fn main() {
+    // What we saw before:
+    let mut t: Vec<_> = vec![]; // Type: Vec<?T>
+    let mut u: Option<_> = None; // Type: Option<?U>
+    foo(t, u); // `Vec<?T>: Borrow<?U>` => ambiguous
+
+    // New stuff:
+    u = Some(vec![]); // ?U = Vec<?V>
+}
+```
+
+As a result of this assignment, the type of `u` is forced to be
+`Option<Vec<?V>>`, where `?V` represents the element type of the
+vector. This in turn implies that `?U` is [unified] to `Vec<?V>`.
+
+[unified]: ../type-checking.html
+
+Let's suppose that the type checker decides to revisit the
+"as-yet-unproven" trait obligation we saw before, `Vec<?T>:
+Borrow<?U>`. `?U` is no longer an unbound inference variable; it now
+has a value, `Vec<?V>`. So, if we "refresh" the query with that value, we get:
+
+```text
+Vec<?T>: Borrow<Vec<?V>>
+```
+
+This time, there is only one impl that applies, the reflexive impl:
+
+```text
+impl<T> Borrow<T> for T where T: ?Sized
+```
+
+Therefore, the trait checker will answer:
+
+- Certainty: `Proven`
+- Var values: `[?T = ?T, ?V = ?T]`
+
+Here, it is saying that we have indeed proven that the obligation
+holds, and we also know that `?T` and `?V` are the same type (but we
+don't know what that type is yet!).
+
+(In fact, as the function ends here, the type checker would give an
+error at this point, since the element types of `t` and `u` are still
+not yet known, even though they are known to be the same.)
+
+
diff --git a/src/doc/rustc-dev-guide/src/traits/chalk.md b/src/doc/rustc-dev-guide/src/traits/chalk.md
new file mode 100644
index 000000000..d4045c460
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/chalk.md
@@ -0,0 +1,41 @@
+# Chalk-based trait solving
+
+[Chalk][chalk] is an experimental trait solver for Rust that is (as of <!--
+date: 2022-05 --> May 2022) under development by the [Types team].
+Its goal is to enable a lot of trait system features and bug fixes
+that are hard to implement (e.g. GATs or specialization). If you would like to
+help in hacking on the new solver, drop by on the rust-lang Zulip in the [`#t-types`]
+stream and say hello!
+
+[Types team]: https://github.com/rust-lang/types-team
+[`#t-types`]: https://rust-lang.zulipchat.com/#narrow/stream/144729-t-types
+
+The new-style trait solver is based on the work done in [chalk][chalk]. Chalk
+recasts Rust's trait system explicitly in terms of logic programming. It does
+this by "lowering" Rust code into a kind of logic program we can then execute
+queries against.
+
+The key observation here is that the Rust trait system is basically a
+kind of logic, and it can be mapped onto standard logical inference
+rules. We can then look for solutions to those inference rules in a
+very similar fashion to how e.g. a [Prolog] solver works. It turns out
+that we can't *quite* use Prolog rules (also called Horn clauses) but
+rather need a somewhat more expressive variant.
+
+[Prolog]: https://en.wikipedia.org/wiki/Prolog
+
+You can read more about chalk itself in the
+[Chalk book](https://rust-lang.github.io/chalk/book/) section.
+
+## Ongoing work
+The design of the new-style trait solving happens in two places:
+
+**chalk**. The [chalk][chalk] repository is where we experiment with new ideas
+and designs for the trait system.
+
+**rustc**. Once we are happy with the logical rules, we proceed to
+implementing them in rustc. We map our struct, trait, and impl declarations
+into logical inference rules in the lowering module in rustc.
+
+[chalk]: https://github.com/rust-lang/chalk
+[rustc_traits]: https://github.com/rust-lang/rust/tree/master/compiler/rustc_traits
diff --git a/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md b/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md
new file mode 100644
index 000000000..4315b3e0f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/goals-and-clauses.md
@@ -0,0 +1,272 @@
+# Goals and clauses
+
+<!-- toc -->
+
+In logic programming terms, a **goal** is something that you must
+prove and a **clause** is something that you know is true. As
+described in the [lowering to logic](./lowering-to-logic.html)
+chapter, Rust's trait solver is based on an extension of hereditary
+harrop (HH) clauses, which extend traditional Prolog Horn clauses with
+a few new superpowers.
+
+## Goals and clauses meta structure
+
+In Rust's solver, **goals** and **clauses** have the following forms
+(note that the two definitions reference one another):
+
+```text
+Goal = DomainGoal           // defined in the section below
+        | Goal && Goal
+        | Goal || Goal
+        | exists<K> { Goal }   // existential quantification
+        | forall<K> { Goal }   // universal quantification
+        | if (Clause) { Goal } // implication
+        | true                 // something that's trivially true
+        | ambiguous            // something that's never provable
+
+Clause = DomainGoal
+        | Clause :- Goal     // if can prove Goal, then Clause is true
+        | Clause && Clause
+        | forall<K> { Clause }
+
+K = <type>     // a "kind"
+    | <lifetime>
+```
+
+The proof procedure for these sorts of goals is actually quite
+straightforward.  Essentially, it's a form of depth-first search. The
+paper
+["A Proof Procedure for the Logic of Hereditary Harrop Formulas"][pphhf]
+gives the details.
+
+In terms of code, these types are defined in
+[`rustc_middle/src/traits/mod.rs`][traits_mod] in rustc, and in
+[`chalk-ir/src/lib.rs`][chalk_ir] in chalk.
+
+[pphhf]: https://rust-lang.github.io/chalk/book/bibliography.html#pphhf
+[traits_mod]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/traits/mod.rs
+[chalk_ir]: https://github.com/rust-lang/chalk/blob/master/chalk-ir/src/lib.rs
+
+<a name="domain-goals"></a>
+
+## Domain goals
+
+*Domain goals* are the atoms of the trait logic. As can be seen in the
+definitions given above, general goals basically consist in a combination of
+domain goals.
+
+Moreover, flattening a bit the definition of clauses given previously, one can
+see that clauses are always of the form:
+```text
+forall<K1, ..., Kn> { DomainGoal :- Goal }
+```
+hence domain goals are in fact clauses' LHS. That is, at the most granular level,
+domain goals are what the trait solver will end up trying to prove.
+
+<a name="trait-ref"></a>
+
+To define the set of domain goals in our system, we need to first
+introduce a few simple formulations. A **trait reference** consists of
+the name of a trait along with a suitable set of inputs P0..Pn:
+
+```text
+TraitRef = P0: TraitName<P1..Pn>
+```
+
+So, for example, `u32: Display` is a trait reference, as is `Vec<T>:
+IntoIterator`. Note that Rust surface syntax also permits some extra
+things, like associated type bindings (`Vec<T>: IntoIterator<Item =
+T>`), that are not part of a trait reference.
+
+<a name="projection"></a>
+
+A **projection** consists of an associated item reference along with
+its inputs P0..Pm:
+
+```text
+Projection = <P0 as TraitName<P1..Pn>>::AssocItem<Pn+1..Pm>
+```
+
+Given these, we can define a `DomainGoal` as follows:
+
+```text
+DomainGoal = Holds(WhereClause)
+            | FromEnv(TraitRef)
+            | FromEnv(Type)
+            | WellFormed(TraitRef)
+            | WellFormed(Type)
+            | Normalize(Projection -> Type)
+
+WhereClause = Implemented(TraitRef)
+            | ProjectionEq(Projection = Type)
+            | Outlives(Type: Region)
+            | Outlives(Region: Region)
+```
+
+`WhereClause` refers to a `where` clause that a Rust user would actually be able
+to write in a Rust program. This abstraction exists only as a convenience as we
+sometimes want to only deal with domain goals that are effectively writable in
+Rust.
+
+Let's break down each one of these, one-by-one.
+
+#### Implemented(TraitRef)
+e.g. `Implemented(i32: Copy)`
+
+True if the given trait is implemented for the given input types and lifetimes.
+
+#### ProjectionEq(Projection = Type)
+e.g. `ProjectionEq<T as Iterator>::Item = u8`
+
+The given associated type `Projection` is equal to `Type`; this can be proved
+with either normalization or using placeholder associated types. See
+[the section on associated types in Chalk Book][at].
+
+#### Normalize(Projection -> Type)
+e.g. `ProjectionEq<T as Iterator>::Item -> u8`
+
+The given associated type `Projection` can be [normalized][n] to `Type`.
+
+As discussed in [the section on associated
+types in Chalk Book][at], `Normalize` implies `ProjectionEq`,
+but not vice versa. In general, proving `Normalize(<T as Trait>::Item -> U)`
+also requires proving `Implemented(T: Trait)`.
+
+[n]: https://rust-lang.github.io/chalk/book/clauses/type_equality.html#normalize
+[at]: https://rust-lang.github.io/chalk/book/clauses/type_equality.html
+
+#### FromEnv(TraitRef)
+e.g. `FromEnv(Self: Add<i32>)`
+
+True if the inner `TraitRef` is *assumed* to be true,
+that is, if it can be derived from the in-scope where clauses.
+
+For example, given the following function:
+
+```rust
+fn loud_clone<T: Clone>(stuff: &T) -> T {
+    println!("cloning!");
+    stuff.clone()
+}
+```
+
+Inside the body of our function, we would have `FromEnv(T: Clone)`. In-scope
+where clauses nest, so a function body inside an impl body inherits the
+impl body's where clauses, too.
+
+This and the next rule are used to implement [implied bounds]. As we'll see
+in the section on lowering, `FromEnv(TraitRef)` implies `Implemented(TraitRef)`,
+but not vice versa. This distinction is crucial to implied bounds.
+
+#### FromEnv(Type)
+e.g. `FromEnv(HashSet<K>)`
+
+True if the inner `Type` is *assumed* to be well-formed, that is, if it is an
+input type of a function or an impl.
+
+For example, given the following code:
+
+```rust,ignore
+struct HashSet<K> where K: Hash { ... }
+
+fn loud_insert<K>(set: &mut HashSet<K>, item: K) {
+    println!("inserting!");
+    set.insert(item);
+}
+```
+
+`HashSet<K>` is an input type of the `loud_insert` function. Hence, we assume it
+to be well-formed, so we would have `FromEnv(HashSet<K>)` inside the body of our
+function. As we'll see in the section on lowering, `FromEnv(HashSet<K>)` implies
+`Implemented(K: Hash)` because the
+`HashSet` declaration was written with a `K: Hash` where clause. Hence, we don't
+need to repeat that bound on the `loud_insert` function: we rather automatically
+assume that it is true.
+
+#### WellFormed(Item)
+These goals imply that the given item is *well-formed*.
+
+We can talk about different types of items being well-formed:
+
+* *Types*, like `WellFormed(Vec<i32>)`, which is true in Rust, or
+  `WellFormed(Vec<str>)`, which is not (because `str` is not `Sized`.)
+
+* *TraitRefs*, like `WellFormed(Vec<i32>: Clone)`.
+
+Well-formedness is important to [implied bounds]. In particular, the reason
+it is okay to assume `FromEnv(T: Clone)` in the `loud_clone` example is that we
+_also_ verify `WellFormed(T: Clone)` for each call site of `loud_clone`.
+Similarly, it is okay to assume `FromEnv(HashSet<K>)` in the `loud_insert`
+example because we will verify `WellFormed(HashSet<K>)` for each call site of
+`loud_insert`.
+
+#### Outlives(Type: Region), Outlives(Region: Region)
+e.g. `Outlives(&'a str: 'b)`, `Outlives('a: 'static)`
+
+True if the given type or region on the left outlives the right-hand region.
+
+<a name="coinductive"></a>
+
+## Coinductive goals
+
+Most goals in our system are "inductive". In an inductive goal,
+circular reasoning is disallowed. Consider this example clause:
+
+```text
+    Implemented(Foo: Bar) :-
+        Implemented(Foo: Bar).
+```
+
+Considered inductively, this clause is useless: if we are trying to
+prove `Implemented(Foo: Bar)`, we would then recursively have to prove
+`Implemented(Foo: Bar)`, and that cycle would continue ad infinitum
+(the trait solver will terminate here, it would just consider that
+`Implemented(Foo: Bar)` is not known to be true).
+
+However, some goals are *co-inductive*. Simply put, this means that
+cycles are OK. So, if `Bar` were a co-inductive trait, then the rule
+above would be perfectly valid, and it would indicate that
+`Implemented(Foo: Bar)` is true.
+
+*Auto traits* are one example in Rust where co-inductive goals are used.
+Consider the `Send` trait, and imagine that we have this struct:
+
+```rust
+struct Foo {
+    next: Option<Box<Foo>>
+}
+```
+
+The default rules for auto traits say that `Foo` is `Send` if the
+types of its fields are `Send`. Therefore, we would have a rule like
+
+```text
+Implemented(Foo: Send) :-
+    Implemented(Option<Box<Foo>>: Send).
+```
+
+As you can probably imagine, proving that `Option<Box<Foo>>: Send` is
+going to wind up circularly requiring us to prove that `Foo: Send`
+again. So this would be an example where we wind up in a cycle – but
+that's ok, we *do* consider `Foo: Send` to hold, even though it
+references itself.
+
+In general, co-inductive traits are used in Rust trait solving when we
+want to enumerate a fixed set of possibilities. In the case of auto
+traits, we are enumerating the set of reachable types from a given
+starting point (i.e., `Foo` can reach values of type
+`Option<Box<Foo>>`, which implies it can reach values of type
+`Box<Foo>`, and then of type `Foo`, and then the cycle is complete).
+
+In addition to auto traits, `WellFormed` predicates are co-inductive.
+These are used to achieve a similar "enumerate all the cases" pattern,
+as described in the section on [implied bounds].
+
+[implied bounds]: https://rust-lang.github.io/chalk/book/clauses/implied_bounds.html#implied-bounds
+
+## Incomplete chapter
+
+Some topics yet to be written:
+
+- Elaborate on the proof procedure
+- SLG solving – introduce negative reasoning
diff --git a/src/doc/rustc-dev-guide/src/traits/hrtb.md b/src/doc/rustc-dev-guide/src/traits/hrtb.md
new file mode 100644
index 000000000..aa85448af
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/hrtb.md
@@ -0,0 +1,127 @@
+# Higher-ranked trait bounds
+
+One of the more subtle concepts in trait resolution is *higher-ranked trait
+bounds*. An example of such a bound is `for<'a> MyTrait<&'a isize>`.
+Let's walk through how selection on higher-ranked trait references
+works.
+
+## Basic matching and placeholder leaks
+
+Suppose we have a trait `Foo`:
+
+```rust
+trait Foo<X> {
+    fn foo(&self, x: X) { }
+}
+```
+
+Let's say we have a function `want_hrtb` that wants a type which
+implements `Foo<&'a isize>` for any `'a`:
+
+```rust,ignore
+fn want_hrtb<T>() where T : for<'a> Foo<&'a isize> { ... }
+```
+
+Now we have a struct `AnyInt` that implements `Foo<&'a isize>` for any
+`'a`:
+
+```rust,ignore
+struct AnyInt;
+impl<'a> Foo<&'a isize> for AnyInt { }
+```
+
+And the question is, does `AnyInt : for<'a> Foo<&'a isize>`? We want the
+answer to be yes. The algorithm for figuring it out is closely related
+to the subtyping for higher-ranked types (which is described [here][hrsubtype]
+and also in a [paper by SPJ]. If you wish to understand higher-ranked
+subtyping, we recommend you read the paper). There are a few parts:
+
+1. Replace bound regions in the obligation with placeholders.
+2. Match the impl against the [placeholder] obligation.
+3. Check for _placeholder leaks_.
+
+[hrsubtype]: ./hrtb.md
+[placeholder]: ../appendix/glossary.html#placeholder
+[paper by SPJ]: https://www.microsoft.com/en-us/research/publication/practical-type-inference-for-arbitrary-rank-types
+
+So let's work through our example.
+
+1. The first thing we would do is to
+replace the bound region in the obligation with a placeholder, yielding 
+`AnyInt : Foo<&'0 isize>` (here `'0` represents placeholder region #0). 
+Note that we now have no quantifiers;
+in terms of the compiler type, this changes from a `ty::PolyTraitRef`
+to a `TraitRef`. We would then create the `TraitRef` from the impl,
+using fresh variables for it's bound regions (and thus getting
+`Foo<&'$a isize>`, where `'$a` is the inference variable for `'a`).
+
+2. Next
+we relate the two trait refs, yielding a graph with the constraint
+that `'0 == '$a`.
+
+3. Finally, we check for placeholder "leaks" – a
+leak is basically any attempt to relate a placeholder region to another
+placeholder region, or to any region that pre-existed the impl match.
+The leak check is done by searching from the placeholder region to find
+the set of regions that it is related to in any way. This is called
+the "taint" set. To pass the check, that set must consist *solely* of
+itself and region variables from the impl. If the taint set includes
+any other region, then the match is a failure. In this case, the taint
+set for `'0` is `{'0, '$a}`, and hence the check will succeed.
+
+Let's consider a failure case. Imagine we also have a struct
+
+```rust,ignore
+struct StaticInt;
+impl Foo<&'static isize> for StaticInt;
+```
+
+We want the obligation `StaticInt : for<'a> Foo<&'a isize>` to be
+considered unsatisfied. The check begins just as before. `'a` is
+replaced with a placeholder `'0` and the impl trait reference is instantiated to
+`Foo<&'static isize>`. When we relate those two, we get a constraint
+like `'static == '0`. This means that the taint set for `'0` is `{'0,
+'static}`, which fails the leak check.
+
+**TODO**: This is because `'static` is not a region variable but is in the
+taint set, right?
+
+## Higher-ranked trait obligations
+
+Once the basic matching is done, we get to another interesting topic:
+how to deal with impl obligations. I'll work through a simple example
+here. Imagine we have the traits `Foo` and `Bar` and an associated impl:
+
+```rust
+trait Foo<X> {
+    fn foo(&self, x: X) { }
+}
+
+trait Bar<X> {
+    fn bar(&self, x: X) { }
+}
+
+impl<X,F> Foo<X> for F
+    where F : Bar<X>
+{
+}
+```
+
+Now let's say we have an obligation `Baz: for<'a> Foo<&'a isize>` and we match
+this impl. What obligation is generated as a result? We want to get
+`Baz: for<'a> Bar<&'a isize>`, but how does that happen?
+
+After the matching, we are in a position where we have a placeholder
+substitution like `X => &'0 isize`. If we apply this substitution to the
+impl obligations, we get `F : Bar<&'0 isize>`. Obviously this is not
+directly usable because the placeholder region `'0` cannot leak out of
+our computation.
+
+What we do is to create an inverse mapping from the taint set of `'0`
+back to the original bound region (`'a`, here) that `'0` resulted
+from. (This is done in `higher_ranked::plug_leaks`). We know that the
+leak check passed, so this taint set consists solely of the placeholder
+region itself plus various intermediate region variables. We then walk
+the trait-reference and convert every region in that taint set back to
+a late-bound region, so in this case we'd wind up with
+`Baz: for<'a> Bar<&'a isize>`.
diff --git a/src/doc/rustc-dev-guide/src/traits/lowering-to-logic.md b/src/doc/rustc-dev-guide/src/traits/lowering-to-logic.md
new file mode 100644
index 000000000..1248d4346
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/lowering-to-logic.md
@@ -0,0 +1,187 @@
+# Lowering to logic
+
+<!-- toc -->
+
+The key observation here is that the Rust trait system is basically a
+kind of logic, and it can be mapped onto standard logical inference
+rules. We can then look for solutions to those inference rules in a
+very similar fashion to how e.g. a [Prolog] solver works. It turns out
+that we can't *quite* use Prolog rules (also called Horn clauses) but
+rather need a somewhat more expressive variant.
+
+[Prolog]: https://en.wikipedia.org/wiki/Prolog
+
+## Rust traits and logic
+
+One of the first observations is that the Rust trait system is
+basically a kind of logic. As such, we can map our struct, trait, and
+impl declarations into logical inference rules. For the most part,
+these are basically Horn clauses, though we'll see that to capture the
+full richness of Rust – and in particular to support generic
+programming – we have to go a bit further than standard Horn clauses.
+
+To see how this mapping works, let's start with an example. Imagine
+we declare a trait and a few impls, like so:
+
+```rust
+trait Clone { }
+impl Clone for usize { }
+impl<T> Clone for Vec<T> where T: Clone { }
+```
+
+We could map these declarations to some Horn clauses, written in a
+Prolog-like notation, as follows:
+
+```text
+Clone(usize).
+Clone(Vec<?T>) :- Clone(?T).
+
+// The notation `A :- B` means "A is true if B is true".
+// Or, put another way, B implies A.
+```
+
+In Prolog terms, we might say that `Clone(Foo)` – where `Foo` is some
+Rust type – is a *predicate* that represents the idea that the type
+`Foo` implements `Clone`. These rules are **program clauses**; they
+state the conditions under which that predicate can be proven (i.e.,
+considered true). So the first rule just says "Clone is implemented
+for `usize`". The next rule says "for any type `?T`, Clone is
+implemented for `Vec<?T>` if clone is implemented for `?T`". So
+e.g. if we wanted to prove that `Clone(Vec<Vec<usize>>)`, we would do
+so by applying the rules recursively:
+
+- `Clone(Vec<Vec<usize>>)` is provable if:
+  - `Clone(Vec<usize>)` is provable if:
+    - `Clone(usize)` is provable. (Which it is, so we're all good.)
+
+But now suppose we tried to prove that `Clone(Vec<Bar>)`. This would
+fail (after all, I didn't give an impl of `Clone` for `Bar`):
+
+- `Clone(Vec<Bar>)` is provable if:
+  - `Clone(Bar)` is provable. (But it is not, as there are no applicable rules.)
+
+We can easily extend the example above to cover generic traits with
+more than one input type. So imagine the `Eq<T>` trait, which declares
+that `Self` is equatable with a value of type `T`:
+
+```rust,ignore
+trait Eq<T> { ... }
+impl Eq<usize> for usize { }
+impl<T: Eq<U>> Eq<Vec<U>> for Vec<T> { }
+```
+
+That could be mapped as follows:
+
+```text
+Eq(usize, usize).
+Eq(Vec<?T>, Vec<?U>) :- Eq(?T, ?U).
+```
+
+So far so good.
+
+## Type-checking normal functions
+
+OK, now that we have defined some logical rules that are able to
+express when traits are implemented and to handle associated types,
+let's turn our focus a bit towards **type-checking**. Type-checking is
+interesting because it is what gives us the goals that we need to
+prove. That is, everything we've seen so far has been about how we
+derive the rules by which we can prove goals from the traits and impls
+in the program; but we are also interested in how to derive the goals
+that we need to prove, and those come from type-checking.
+
+Consider type-checking the function `foo()` here:
+
+```rust,ignore
+fn foo() { bar::<usize>() }
+fn bar<U: Eq<U>>() { }
+```
+
+This function is very simple, of course: all it does is to call
+`bar::<usize>()`. Now, looking at the definition of `bar()`, we can see
+that it has one where-clause `U: Eq<U>`. So, that means that `foo()` will
+have to prove that `usize: Eq<usize>` in order to show that it can call `bar()`
+with `usize` as the type argument.
+
+If we wanted, we could write a Prolog predicate that defines the
+conditions under which `bar()` can be called. We'll say that those
+conditions are called being "well-formed":
+
+```text
+barWellFormed(?U) :- Eq(?U, ?U).
+```
+
+Then we can say that `foo()` type-checks if the reference to
+`bar::<usize>` (that is, `bar()` applied to the type `usize`) is
+well-formed:
+
+```text
+fooTypeChecks :- barWellFormed(usize).
+```
+
+If we try to prove the goal `fooTypeChecks`, it will succeed:
+
+- `fooTypeChecks` is provable if:
+  - `barWellFormed(usize)`, which is provable if:
+    - `Eq(usize, usize)`, which is provable because of an impl.
+
+Ok, so far so good. Let's move on to type-checking a more complex function.
+
+## Type-checking generic functions: beyond Horn clauses
+
+In the last section, we used standard Prolog horn-clauses (augmented with Rust's
+notion of type equality) to type-check some simple Rust functions. But that only
+works when we are type-checking non-generic functions. If we want to type-check
+a generic function, it turns out we need a stronger notion of goal than what Prolog
+can provide. To see what I'm talking about, let's revamp our previous
+example to make `foo` generic:
+
+```rust,ignore
+fn foo<T: Eq<T>>() { bar::<T>() }
+fn bar<U: Eq<U>>() { }
+```
+
+To type-check the body of `foo`, we need to be able to hold the type
+`T` "abstract".  That is, we need to check that the body of `foo` is
+type-safe *for all types `T`*, not just for some specific type. We might express
+this like so:
+
+```text
+fooTypeChecks :-
+  // for all types T...
+  forall<T> {
+    // ...if we assume that Eq(T, T) is provable...
+    if (Eq(T, T)) {
+      // ...then we can prove that `barWellFormed(T)` holds.
+      barWellFormed(T)
+    }
+  }.
+```
+
+This notation I'm using here is the notation I've been using in my
+prototype implementation; it's similar to standard mathematical
+notation but a bit Rustified. Anyway, the problem is that standard
+Horn clauses don't allow universal quantification (`forall`) or
+implication (`if`) in goals (though many Prolog engines do support
+them, as an extension). For this reason, we need to accept something
+called "first-order hereditary harrop" (FOHH) clauses – this long
+name basically means "standard Horn clauses with `forall` and `if` in
+the body". But it's nice to know the proper name, because there is a
+lot of work describing how to efficiently handle FOHH clauses; see for
+example Gopalan Nadathur's excellent
+["A Proof Procedure for the Logic of Hereditary Harrop Formulas"][pphhf]
+in [the bibliography of Chalk Book][bibliography].
+
+[bibliography]: https://rust-lang.github.io/chalk/book/bibliography.html
+[pphhf]: https://rust-lang.github.io/chalk/book/bibliography.html#pphhf
+
+It turns out that supporting FOHH is not really all that hard. And
+once we are able to do that, we can easily describe the type-checking
+rule for generic functions like `foo` in our logic.
+
+## Source
+
+This page is a lightly adapted version of a
+[blog post by Nicholas Matsakis][lrtl].
+
+[lrtl]: http://smallcultfollowing.com/babysteps/blog/2017/01/26/lowering-rust-traits-to-logic/
diff --git a/src/doc/rustc-dev-guide/src/traits/resolution.md b/src/doc/rustc-dev-guide/src/traits/resolution.md
new file mode 100644
index 000000000..c22ee6de6
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/resolution.md
@@ -0,0 +1,318 @@
+# Trait resolution (old-style)
+
+<!-- toc -->
+
+This chapter describes the general process of _trait resolution_ and points out
+some non-obvious things.
+
+**Note:** This chapter (and its subchapters) describe how the trait
+solver **currently** works. However, we are in the process of
+designing a new trait solver. If you'd prefer to read about *that*,
+see [*this* subchapter](./chalk.html).
+
+## Major concepts
+
+Trait resolution is the process of pairing up an impl with each
+reference to a trait. So, for example, if there is a generic function like:
+
+```rust,ignore
+fn clone_slice<T:Clone>(x: &[T]) -> Vec<T> { ... }
+```
+
+and then a call to that function:
+
+```rust,ignore
+let v: Vec<isize> = clone_slice(&[1, 2, 3])
+```
+
+it is the job of trait resolution to figure out whether there exists an impl of
+(in this case) `isize : Clone`.
+
+Note that in some cases, like generic functions, we may not be able to
+find a specific impl, but we can figure out that the caller must
+provide an impl. For example, consider the body of `clone_slice`:
+
+```rust,ignore
+fn clone_slice<T:Clone>(x: &[T]) -> Vec<T> {
+    let mut v = Vec::new();
+    for e in &x {
+        v.push((*e).clone()); // (*)
+    }
+}
+```
+
+The line marked `(*)` is only legal if `T` (the type of `*e`)
+implements the `Clone` trait. Naturally, since we don't know what `T`
+is, we can't find the specific impl; but based on the bound `T:Clone`,
+we can say that there exists an impl which the caller must provide.
+
+We use the term *obligation* to refer to a trait reference in need of
+an impl. Basically, the trait resolution system resolves an obligation
+by proving that an appropriate impl does exist.
+
+During type checking, we do not store the results of trait selection.
+We simply wish to verify that trait selection will succeed. Then
+later, at trans time, when we have all concrete types available, we
+can repeat the trait selection to choose an actual implementation, which
+will then be generated in the output binary.
+
+## Overview
+
+Trait resolution consists of three major parts:
+
+- **Selection**: Deciding how to resolve a specific obligation. For
+  example, selection might decide that a specific obligation can be
+  resolved by employing an impl which matches the `Self` type, or by using a
+  parameter bound (e.g. `T: Trait`). In the case of an impl, selecting one
+  obligation can create *nested obligations* because of where clauses
+  on the impl itself. It may also require evaluating those nested
+  obligations to resolve ambiguities.
+
+- **Fulfillment**: The fulfillment code is what tracks that obligations
+  are completely fulfilled. Basically it is a worklist of obligations
+  to be selected: once selection is successful, the obligation is
+  removed from the worklist and any nested obligations are enqueued.
+
+- **Coherence**: The coherence checks are intended to ensure that there
+  are never overlapping impls, where two impls could be used with
+  equal precedence.
+
+## Selection
+
+Selection is the process of deciding whether an obligation can be
+resolved and, if so, how it is to be resolved (via impl, where clause, etc).
+The main interface is the `select()` function, which takes an obligation
+and returns a `SelectionResult`. There are three possible outcomes:
+
+- `Ok(Some(selection))` – yes, the obligation can be resolved, and
+  `selection` indicates how. If the impl was resolved via an impl,
+  then `selection` may also indicate nested obligations that are required
+  by the impl.
+
+- `Ok(None)` – we are not yet sure whether the obligation can be
+  resolved or not. This happens most commonly when the obligation
+  contains unbound type variables.
+
+- `Err(err)` – the obligation definitely cannot be resolved due to a
+  type error or because there are no impls that could possibly apply.
+
+The basic algorithm for selection is broken into two big phases:
+candidate assembly and confirmation.
+
+Note that because of how lifetime inference works, it is not possible to
+give back immediate feedback as to whether a unification or subtype
+relationship between lifetimes holds or not. Therefore, lifetime
+matching is *not* considered during selection. This is reflected in
+the fact that subregion assignment is infallible. This may yield
+lifetime constraints that will later be found to be in error (in
+contrast, the non-lifetime-constraints have already been checked
+during selection and can never cause an error, though naturally they
+may lead to other errors downstream).
+
+### Candidate assembly
+
+Searches for impls/where-clauses/etc that might
+possibly be used to satisfy the obligation. Each of those is called
+a candidate. To avoid ambiguity, we want to find exactly one
+candidate that is definitively applicable. In some cases, we may not
+know whether an impl/where-clause applies or not – this occurs when
+the obligation contains unbound inference variables.
+
+The subroutines that decide whether a particular impl/where-clause/etc applies
+to a particular obligation are collectively referred to as the process of
+_matching_. As of <!-- date: 2022-05 --> May 2022, this amounts to unifying
+the `Self` types, but in the future we may also recursively consider some of the
+nested obligations, in the case of an impl.
+
+**TODO**: what does "unifying the `Self` types" mean? The `Self` of the
+obligation with that of an impl?
+
+The basic idea for candidate assembly is to do a first pass in which
+we identify all possible candidates. During this pass, all that we do
+is try and unify the type parameters. (In particular, we ignore any
+nested where clauses.) Presuming that this unification succeeds, the
+impl is added as a candidate.
+
+Once this first pass is done, we can examine the set of candidates. If
+it is a singleton set, then we are done: this is the only impl in
+scope that could possibly apply. Otherwise, we can winnow down the set
+of candidates by using where clauses and other conditions. If this
+reduced set yields a single, unambiguous entry, we're good to go,
+otherwise the result is considered ambiguous.
+
+#### The basic process: Inferring based on the impls we see
+
+This process is easier if we work through some examples. Consider
+the following trait:
+
+```rust,ignore
+trait Convert<Target> {
+    fn convert(&self) -> Target;
+}
+```
+
+This trait just has one method. It's about as simple as it gets. It
+converts from the (implicit) `Self` type to the `Target` type. If we
+wanted to permit conversion between `isize` and `usize`, we might
+implement `Convert` like so:
+
+```rust,ignore
+impl Convert<usize> for isize { ... } // isize -> usize
+impl Convert<isize> for usize { ... } // usize -> isize
+```
+
+Now imagine there is some code like the following:
+
+```rust,ignore
+let x: isize = ...;
+let y = x.convert();
+```
+
+The call to convert will generate a trait reference `Convert<$Y> for
+isize`, where `$Y` is the type variable representing the type of
+`y`. Of the two impls we can see, the only one that matches is
+`Convert<usize> for isize`. Therefore, we can
+select this impl, which will cause the type of `$Y` to be unified to
+`usize`. (Note that while assembling candidates, we do the initial
+unifications in a transaction, so that they don't affect one another.)
+
+**TODO**: The example says we can "select" the impl, but this section is
+talking specifically about candidate assembly. Does this mean we can sometimes
+skip confirmation? Or is this poor wording?
+**TODO**: Is the unification of `$Y` part of trait resolution or type
+inference? Or is this not the same type of "inference variable" as in type
+inference?
+
+#### Winnowing: Resolving ambiguities
+
+But what happens if there are multiple impls where all the types
+unify? Consider this example:
+
+```rust,ignore
+trait Get {
+    fn get(&self) -> Self;
+}
+
+impl<T: Copy> Get for T {
+    fn get(&self) -> T {
+        *self
+    }
+}
+
+impl<T: Get> Get for Box<T> {
+    fn get(&self) -> Box<T> {
+        Box::new(<T>::get(self))
+    }
+}
+```
+
+What happens when we invoke `get_it(&Box::new(1_u16))`, for example? In this
+case, the `Self` type is `Box<u16>` – that unifies with both impls,
+because the first applies to all types `T`, and the second to all
+`Box<T>`. In order for this to be unambiguous, the compiler does a *winnowing*
+pass that considers `where` clauses
+and attempts to remove candidates. In this case, the first impl only
+applies if `Box<u16> : Copy`, which doesn't hold. After winnowing,
+then, we are left with just one candidate, so we can proceed.
+
+#### `where` clauses
+
+Besides an impl, the other major way to resolve an obligation is via a
+where clause. The selection process is always given a [parameter
+environment] which contains a list of where clauses, which are
+basically obligations that we can assume are satisfiable. We will iterate
+over that list and check whether our current obligation can be found
+in that list. If so, it is considered satisfied. More precisely, we
+want to check whether there is a where-clause obligation that is for
+the same trait (or some subtrait) and which can match against the obligation.
+
+[parameter environment]: ../param_env.html
+
+Consider this simple example:
+
+```rust,ignore
+trait A1 {
+    fn do_a1(&self);
+}
+trait A2 : A1 { ... }
+
+trait B {
+    fn do_b(&self);
+}
+
+fn foo<X:A2+B>(x: X) {
+    x.do_a1(); // (*)
+    x.do_b();  // (#)
+}
+```
+
+In the body of `foo`, clearly we can use methods of `A1`, `A2`, or `B`
+on variable `x`. The line marked `(*)` will incur an obligation `X: A1`,
+while the line marked `(#)` will incur an obligation `X: B`. Meanwhile,
+the parameter environment will contain two where-clauses: `X : A2` and `X : B`.
+For each obligation, then, we search this list of where-clauses. The
+obligation `X: B` trivially matches against the where-clause `X: B`.
+To resolve an obligation `X:A1`, we would note that `X:A2` implies that `X:A1`.
+
+### Confirmation
+
+_Confirmation_ unifies the output type parameters of the trait with the
+values found in the obligation, possibly yielding a type error.
+
+Suppose we have the following variation of the `Convert` example in the
+previous section:
+
+```rust,ignore
+trait Convert<Target> {
+    fn convert(&self) -> Target;
+}
+
+impl Convert<usize> for isize { ... } // isize -> usize
+impl Convert<isize> for usize { ... } // usize -> isize
+
+let x: isize = ...;
+let y: char = x.convert(); // NOTE: `y: char` now!
+```
+
+Confirmation is where an error would be reported because the impl specified
+that `Target` would be `usize`, but the obligation reported `char`. Hence the
+result of selection would be an error.
+
+Note that the candidate impl is chosen based on the `Self` type, but
+confirmation is done based on (in this case) the `Target` type parameter.
+
+### Selection during translation
+
+As mentioned above, during type checking, we do not store the results of trait
+selection. At trans time, we repeat the trait selection to choose a particular
+impl for each method call. In this second selection, we do not consider any
+where-clauses to be in scope because we know that each resolution will resolve
+to a particular impl.
+
+One interesting twist has to do with nested obligations. In general, in trans,
+we only need to do a "shallow" selection for an obligation. That is, we wish to
+identify which impl applies, but we do not (yet) need to decide how to select
+any nested obligations. Nonetheless, we *do* currently do a complete resolution,
+and that is because it can sometimes inform the results of type inference.
+That is, we do not have the full substitutions in terms of the type variables
+of the impl available to us, so we must run trait selection to figure
+everything out.
+
+**TODO**: is this still talking about trans?
+
+Here is an example:
+
+```rust,ignore
+trait Foo { ... }
+impl<U, T:Bar<U>> Foo for Vec<T> { ... }
+
+impl Bar<usize> for isize { ... }
+```
+
+After one shallow round of selection for an obligation like `Vec<isize>
+: Foo`, we would know which impl we want, and we would know that
+`T=isize`, but we do not know the type of `U`.  We must select the
+nested obligation `isize : Bar<U>` to find out that `U=usize`.
+
+It would be good to only do *just as much* nested resolution as
+necessary. Currently, though, we just do a full resolution.
diff --git a/src/doc/rustc-dev-guide/src/traits/specialization.md b/src/doc/rustc-dev-guide/src/traits/specialization.md
new file mode 100644
index 000000000..7a30314b4
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/traits/specialization.md
@@ -0,0 +1,51 @@
+# Specialization
+
+**TODO**: where does Chalk fit in? Should we mention/discuss it here?
+
+Defined in the `specialize` module.
+
+The basic strategy is to build up a *specialization graph* during
+coherence checking (recall that coherence checking looks for overlapping
+impls). Insertion into the graph locates the right place
+to put an impl in the specialization hierarchy; if there is no right
+place (due to partial overlap but no containment), you get an overlap
+error. Specialization is consulted when selecting an impl (of course),
+and the graph is consulted when propagating defaults down the
+specialization hierarchy.
+
+You might expect that the specialization graph would be used during
+selection – i.e. when actually performing specialization. This is
+not done for two reasons:
+
+- It's merely an optimization: given a set of candidates that apply,
+  we can determine the most specialized one by comparing them directly
+  for specialization, rather than consulting the graph. Given that we
+  also cache the results of selection, the benefit of this
+  optimization is questionable.
+
+- To build the specialization graph in the first place, we need to use
+  selection (because we need to determine whether one impl specializes
+  another). Dealing with this reentrancy would require some additional
+  mode switch for selection. Given that there seems to be no strong
+  reason to use the graph anyway, we stick with a simpler approach in
+  selection, and use the graph only for propagating default
+  implementations.
+
+Trait impl selection can succeed even when multiple impls can apply,
+as long as they are part of the same specialization family. In that
+case, it returns a *single* impl on success – this is the most
+specialized impl *known* to apply. However, if there are any inference
+variables in play, the returned impl may not be the actual impl we
+will use at trans time. Thus, we take special care to avoid projecting
+associated types unless either (1) the associated type does not use
+`default` and thus cannot be overridden or (2) all input types are
+known concretely.
+
+## Additional Resources
+
+[This talk][talk] by @sunjay may be useful. Keep in mind that the talk only
+gives a broad overview of the problem and the solution (it was presented about
+halfway through @sunjay's work). Also, it was given in June 2018, and some
+things may have changed by the time you watch it.
+
+[talk]: https://www.youtube.com/watch?v=rZqS4bLPL24
diff --git a/src/doc/rustc-dev-guide/src/ty-fold.md b/src/doc/rustc-dev-guide/src/ty-fold.md
new file mode 100644
index 000000000..c390597f9
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/ty-fold.md
@@ -0,0 +1,105 @@
+# `TypeFoldable` and `TypeFolder`
+
+How is this `subst` query actually implemented? As you can imagine, we might want to do
+substitutions on a lot of different things. For example, we might want to do a substitution directly
+on a type like we did with `Vec` above. But we might also have a more complex type with other types
+nested inside that also need substitutions.
+
+The answer is a couple of traits:
+[`TypeFoldable`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFoldable.html)
+and
+[`TypeFolder`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFolder.html).
+
+- `TypeFoldable` is implemented by types that embed type information. It allows you to recursively
+  process the contents of the `TypeFoldable` and do stuff to them.
+- `TypeFolder` defines what you want to do with the types you encounter while processing the
+  `TypeFoldable`.
+
+For example, the `TypeFolder` trait has a method
+[`fold_ty`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFolder.html#method.fold_ty)
+that takes a type as input a type and returns a new type as a result. `TypeFoldable` invokes the
+`TypeFolder` `fold_foo` methods on itself, giving the `TypeFolder` access to its contents (the
+types, regions, etc that are contained within).
+
+You can think of it with this analogy to the iterator combinators we have come to love in rust:
+
+```rust,ignore
+vec.iter().map(|e1| foo(e2)).collect()
+//             ^^^^^^^^^^^^ analogous to `TypeFolder`
+//         ^^^ analogous to `TypeFoldable`
+```
+
+So to reiterate:
+
+- `TypeFolder`  is a trait that defines a “map” operation.
+- `TypeFoldable`  is a trait that is implemented by things that embed types.
+
+In the case of `subst`, we can see that it is implemented as a `TypeFolder`:
+[`SubstFolder`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/subst/struct.SubstFolder.html).
+Looking at its implementation, we see where the actual substitutions are happening.
+
+However, you might also notice that the implementation calls this `super_fold_with` method. What is
+that? It is a method of `TypeFoldable`. Consider the following `TypeFoldable` type `MyFoldable`:
+
+```rust,ignore
+struct MyFoldable<'tcx> {
+  def_id: DefId,
+  ty: Ty<'tcx>,
+}
+```
+
+The `TypeFolder` can call `super_fold_with` on `MyFoldable` if it just wants to replace some of the
+fields of `MyFoldable` with new values. If it instead wants to replace the whole `MyFoldable` with a
+different one, it would call `fold_with` instead (a different method on `TypeFoldable`).
+
+In almost all cases, we don’t want to replace the whole struct; we only want to replace `ty::Ty`s in
+the struct, so usually we call `super_fold_with`. A typical implementation that `MyFoldable` could
+have might do something like this:
+
+```rust,ignore
+my_foldable: MyFoldable<'tcx>
+my_foldable.subst(..., subst)
+
+impl TypeFoldable for MyFoldable {
+  fn super_fold_with(&self, folder: &mut impl TypeFolder<'tcx>) -> MyFoldable {
+    MyFoldable {
+      def_id: self.def_id.fold_with(folder),
+      ty: self.ty.fold_with(folder),
+    }
+  }
+
+  fn super_visit_with(..) { }
+}
+```
+
+Notice that here, we implement `super_fold_with` to go over the fields of `MyFoldable` and call
+`fold_with` on *them*. That is, a folder may replace  `def_id` and `ty`, but not the whole
+`MyFoldable` struct.
+
+Here is another example to put things together: suppose we have a type like `Vec<Vec<X>>`. The
+`ty::Ty` would look like: `Adt(Vec, &[Adt(Vec, &[Param(X)])])`. If we want to do `subst(X => u32)`,
+then we would first look at the overall type. We would see that there are no substitutions to be
+made at the outer level, so we would descend one level and look at `Adt(Vec, &[Param(X)])`. There
+are still no substitutions to be made here, so we would descend again. Now we are looking at
+`Param(X)`, which can be substituted, so we replace it with `u32`. We can’t descend any more, so we
+are done, and  the overall result is `Adt(Vec, &[Adt(Vec, &[u32])])`.
+
+One last thing to mention: often when folding over a `TypeFoldable`, we don’t want to change most
+things. We only want to do something when we reach a type. That means there may be a lot of
+`TypeFoldable` types whose implementations basically just forward to their fields’ `TypeFoldable`
+implementations. Such implementations of `TypeFoldable` tend to be pretty tedious to write by hand.
+For this reason, there is a `derive` macro that allows you to `#![derive(TypeFoldable)]`. It is
+defined
+[here](https://github.com/rust-lang/rust/blob/master/compiler/rustc_macros/src/type_foldable.rs).
+
+**`subst`** In the case of substitutions the [actual
+folder](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L440-L451)
+is going to be doing the indexing we’ve already mentioned. There we define a `Folder` and call
+`fold_with` on the `TypeFoldable` to process yourself.  Then
+[fold_ty](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L512-L536)
+the method that process each type it looks for a `ty::Param` and for those it replaces it for
+something from the list of substitutions, otherwise recursively process the type.  To replace it,
+calls
+[ty_for_param](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L552-L587)
+and all that does is index into the list of substitutions with the index of the `Param`.
+
diff --git a/src/doc/rustc-dev-guide/src/ty.md b/src/doc/rustc-dev-guide/src/ty.md
new file mode 100644
index 000000000..1cc03fce0
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/ty.md
@@ -0,0 +1,348 @@
+# The `ty` module: representing types
+
+<!-- toc -->
+
+The `ty` module defines how the Rust compiler represents types internally. It also defines the
+*typing context* (`tcx` or `TyCtxt`), which is the central data structure in the compiler.
+
+## `ty::Ty`
+
+When we talk about how rustc represents types,  we usually refer to a type called `Ty` . There are
+quite a few modules and types for `Ty` in the compiler ([Ty documentation][ty]).
+
+[ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/index.html
+
+The specific `Ty` we are referring to is [`rustc_middle::ty::Ty`][ty_ty] (and not
+[`rustc_hir::Ty`][hir_ty]). The distinction is important, so we will discuss it first before going
+into the details of `ty::Ty`.
+
+[ty_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html
+[hir_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.Ty.html
+
+## `rustc_hir::Ty` vs `ty::Ty`
+
+The HIR in rustc can be thought of as the high-level intermediate representation. It is more or less
+the AST (see [this chapter](hir.md)) as it represents the
+syntax that the user wrote, and is obtained after parsing and some *desugaring*. It has a
+representation of types, but in reality it reflects more of what the user wrote, that is, what they
+wrote so as to represent that type.
+
+In contrast, `ty::Ty` represents the semantics of a type, that is, the *meaning* of what the user
+wrote. For example, `rustc_hir::Ty` would record the fact that a user used the name `u32` twice
+in their program, but the `ty::Ty` would record the fact that both usages refer to the same type.
+
+**Example: `fn foo(x: u32) → u32 { x }`**
+
+In this function, we see that `u32` appears twice. We know
+that that is the same type,
+i.e. the function takes an argument and returns an argument of the same type,
+but from the point of view of the HIR,
+there would be two distinct type instances because these
+are occurring in two different places in the program.
+That is, they have two different [`Span`s][span] (locations).
+
+[span]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_span/struct.Span.html
+
+**Example: `fn foo(x: &u32) -> &u32`**
+
+In addition, HIR might have information left out. This type
+`&u32` is incomplete, since in the full Rust type there is actually a lifetime, but we didn’t need
+to write those lifetimes. There are also some elision rules that insert information. The result may
+look like  `fn foo<'a>(x: &'a u32) -> &'a u32`.
+
+In the HIR level, these things are not spelled out and you can say the picture is rather incomplete.
+However, at the `ty::Ty` level, these details are added and it is complete. Moreover, we will have
+exactly one `ty::Ty` for a given type, like `u32`, and that `ty::Ty` is used for all `u32`s in the
+whole program, not a specific usage, unlike `rustc_hir::Ty`.
+
+Here is a summary:
+
+| [`rustc_hir::Ty`][hir_ty] | [`ty::Ty`][ty_ty] |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Describe the *syntax* of a type: what the user wrote (with some desugaring).  | Describe the *semantics* of a type: the meaning of what the user wrote. |
+| Each `rustc_hir::Ty` has its own spans corresponding to the appropriate place in the program. | Doesn’t correspond to a single place in the user’s program. |
+| `rustc_hir::Ty` has generics and lifetimes; however, some of those lifetimes are special markers like [`LifetimeName::Implicit`][implicit]. | `ty::Ty` has the full type, including generics and lifetimes, even if the user left them out |
+| `fn foo(x: u32) → u32 { }` - Two `rustc_hir::Ty` representing each usage of `u32`, each has its own `Span`s, and `rustc_hir::Ty` doesn’t tell us that both are the same type | `fn foo(x: u32) → u32 { }` - One `ty::Ty` for all instances of `u32` throughout the program, and `ty::Ty` tells us that both usages of `u32` mean the same type. |
+| `fn foo(x: &u32) -> &u32)` - Two `rustc_hir::Ty` again. Lifetimes for the references show up in the `rustc_hir::Ty`s using a special marker, [`LifetimeName::Implicit`][implicit]. | `fn foo(x: &u32) -> &u32)`- A single `ty::Ty`. The `ty::Ty` has the hidden lifetime param. |
+
+[implicit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/enum.LifetimeName.html#variant.Implicit
+
+**Order**
+
+HIR is built directly from the AST, so it happens before any `ty::Ty` is produced. After
+HIR is built, some basic type inference and type checking is done. During the type inference, we
+figure out what the `ty::Ty` of everything is and we also check if the type of something is
+ambiguous. The `ty::Ty` is then used for type checking while making sure everything has the
+expected type. The [`astconv` module][astconv] is where the code responsible for converting a
+`rustc_hir::Ty` into a `ty::Ty` is located. This occurs during the type-checking phase,
+but also in other parts of the compiler that want to ask questions like "what argument types does
+this function expect?"
+
+[astconv]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/astconv/index.html
+
+**How semantics drive the two instances of `Ty`**
+
+You can think of HIR as the perspective
+of the type information that assumes the least. We assume two things are distinct until they are
+proven to be the same thing. In other words, we know less about them, so we should assume less about
+them.
+
+They are syntactically two strings: `"u32"` at line N column 20 and `"u32"` at line N column 35. We
+don’t know that they are the same yet. So, in the HIR we treat them as if they are different. Later,
+we determine that they semantically are the same type and that’s the `ty::Ty` we use.
+
+Consider another example: `fn foo<T>(x: T) -> u32`. Suppose that someone invokes `foo::<u32>(0)`.
+This means that `T` and `u32` (in this invocation) actually turns out to be the same type, so we
+would eventually end up with the same `ty::Ty` in the end, but we have distinct `rustc_hir::Ty`.
+(This is a bit over-simplified, though, since during type checking, we would check the function
+generically and would still have a `T` distinct from `u32`. Later, when doing code generation,
+we would always be handling "monomorphized" (fully substituted) versions of each function,
+and hence we would know what `T` represents (and specifically that it is `u32`).)
+
+Here is one more example:
+
+```rust
+mod a {
+    type X = u32;
+    pub fn foo(x: X) -> u32 { 22 }
+}
+mod b {
+    type X = i32;
+    pub fn foo(x: X) -> i32 { x }
+}
+```
+
+Here the type `X` will vary depending on context, clearly. If you look at the `rustc_hir::Ty`,
+you will get back that `X` is an alias in both cases (though it will be mapped via name resolution
+to distinct aliases). But if you look at the `ty::Ty` signature, it will be either `fn(u32) -> u32`
+or `fn(i32) -> i32` (with type aliases fully expanded).
+
+## `ty::Ty` implementation
+
+[`rustc_middle::ty::Ty`][ty_ty] is actually a type alias to [`&TyS`][tys].
+This type, which is short for "Type Structure", is where the main functionality is located.
+You can ignore `TyS` struct in general; you will basically never access it explicitly.
+We always pass it by reference using the `Ty` alias.
+The only exception is to define inherent methods on types. In particular, `TyS` has a [`kind`][kind]
+field of type [`TyKind`][tykind], which represents the key type information. `TyKind` is a big enum
+with variants to represent many different Rust types
+(e.g. primitives, references, abstract data types, generics, lifetimes, etc).
+`TyS` also has 2 more fields, `flags` and `outer_exclusive_binder`. They
+are convenient hacks for efficiency and summarize information about the type that we may want to
+know, but they don’t come into the picture as much here. Finally, `ty::TyS`s
+are [interned](./memory.md), so that the `ty::Ty` can be a thin pointer-like
+type. This allows us to do cheap comparisons for equality, along with the other
+benefits of interning.
+
+[tys]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
+[kind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html#structfield.kind
+[tykind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html
+
+## Allocating and working with types
+
+To allocate a new type, you can use the various `mk_` methods defined on the `tcx`. These have names
+that correspond mostly to the various kinds of types. For example:
+
+```rust,ignore
+let array_ty = tcx.mk_array(elem_ty, len * 2);
+```
+
+These methods all return a `Ty<'tcx>` – note that the lifetime you get back is the lifetime of the
+arena that this `tcx` has access to. Types are always canonicalized and interned (so we never
+allocate exactly the same type twice).
+
+> N.B.
+> Because types are interned, it is possible to compare them for equality efficiently using `==`
+> – however, this is almost never what you want to do unless you happen to be hashing and looking
+> for duplicates. This is because often in Rust there are multiple ways to represent the same type,
+> particularly once inference is involved. If you are going to be testing for type equality, you
+> probably need to start looking into the inference code to do it right.
+
+You can also find various common types in the `tcx` itself by accessing its fields:
+`tcx.types.bool`, `tcx.types.char`, etc. (See [`CommonTypes`] for more.)
+
+[`CommonTypes`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.CommonTypes.html
+
+## `ty::TyKind` Variants
+
+Note: `TyKind` is **NOT** the functional programming concept of *Kind*.
+
+Whenever working with a `Ty` in the compiler, it is common to match on the kind of type:
+
+```rust,ignore
+fn foo(x: Ty<'tcx>) {
+  match x.kind {
+    ...
+  }
+}
+```
+
+The `kind` field is of type `TyKind<'tcx>`, which is an enum defining all of the different kinds of
+types in the compiler.
+
+> N.B. inspecting the `kind` field on types during type inference can be risky, as there may be
+> inference variables and other things to consider, or sometimes types are not yet known and will
+> become known later.
+
+There are a lot of related types, and we’ll cover them in time (e.g regions/lifetimes,
+“substitutions”, etc).
+
+There are many variants on the `TyKind` enum, which you can see by looking at its
+[documentation][tykind]. Here is a sampling:
+
+- [**Algebraic Data Types (ADTs)**][kindadt] An [*algebraic data type*][wikiadt] is a  `struct`,
+  `enum` or `union`.  Under the hood, `struct`, `enum` and `union` are actually implemented
+  the same way: they are all [`ty::TyKind::Adt`][kindadt].  It’s basically a user defined type.
+  We will talk more about these later.
+- [**Foreign**][kindforeign] Corresponds to `extern type T`.
+- [**Str**][kindstr] Is the type str. When the user writes `&str`, `Str` is the how we represent the
+  `str` part of that type.
+- [**Slice**][kindslice] Corresponds to `[T]`.
+- [**Array**][kindarray] Corresponds to `[T; n]`.
+- [**RawPtr**][kindrawptr] Corresponds to `*mut T` or `*const T`.
+- [**Ref**][kindref] `Ref` stands for safe references, `&'a mut T` or `&'a T`. `Ref` has some
+  associated parts, like `Ty<'tcx>` which is the type that the reference references.
+  `Region<'tcx>` is the lifetime or region of the reference and `Mutability` if the reference
+  is mutable or not.
+- [**Param**][kindparam] Represents a type parameter (e.g. the `T` in `Vec<T>`).
+- [**Error**][kinderr] Represents a type error somewhere so that we can print better diagnostics. We
+  will discuss this more later.
+- [**And many more**...][kindvars]
+
+[wikiadt]: https://en.wikipedia.org/wiki/Algebraic_data_type
+[kindadt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Adt
+[kindforeign]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Foreign
+[kindstr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Str
+[kindslice]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Slice
+[kindarray]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Array
+[kindrawptr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.RawPtr
+[kindref]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Ref
+[kindparam]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Param
+[kinderr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variant.Error
+[kindvars]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html#variants
+
+## Import conventions
+
+Although there is no hard and fast rule, the `ty` module tends to be used like so:
+
+```rust,ignore
+use ty::{self, Ty, TyCtxt};
+```
+
+In particular, since they are so common, the `Ty` and `TyCtxt` types are imported directly. Other
+types are often referenced with an explicit `ty::` prefix (e.g. `ty::TraitRef<'tcx>`). But some
+modules choose to import a larger or smaller set of names explicitly.
+
+## ADTs Representation
+
+Let's consider the example of a type like `MyStruct<u32>`, where `MyStruct` is defined like so:
+
+```rust,ignore
+struct MyStruct<T> { x: u32, y: T }
+```
+
+The type `MyStruct<u32>` would be an instance of `TyKind::Adt`:
+
+```rust,ignore
+Adt(&'tcx AdtDef, SubstsRef<'tcx>)
+//  ------------  ---------------
+//  (1)            (2)
+//
+// (1) represents the `MyStruct` part
+// (2) represents the `<u32>`, or "substitutions" / generic arguments
+```
+
+There are two parts:
+
+- The [`AdtDef`][adtdef] references the struct/enum/union but without the values for its type
+  parameters. In our example, this is the `MyStruct` part *without* the argument `u32`.
+  (Note that in the HIR, structs, enums and unions are represented differently, but in `ty::Ty`,
+  they are all represented using `TyKind::Adt`.)
+- The [`SubstsRef`][substsref] is an interned list of values that are to be substituted for the
+  generic parameters.  In our example of `MyStruct<u32>`, we would end up with a list like `[u32]`.
+  We’ll dig more into generics and substitutions in a little bit.
+
+[adtdef]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.AdtDef.html
+[substsref]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/subst/type.SubstsRef.html
+
+**`AdtDef` and `DefId`**
+
+For every type defined in the source code, there is a unique `DefId` (see [this
+chapter](hir.md#identifiers-in-the-hir)). This includes ADTs and generics. In the `MyStruct<T>`
+definition we gave above, there are two `DefId`s: one for `MyStruct` and one for `T`.  Notice that
+the code above does not generate a new `DefId` for `u32` because it is not defined in that code (it
+is only referenced).
+
+`AdtDef` is more or less a wrapper around `DefId` with lots of useful helper methods. There is
+essentially a one-to-one relationship between `AdtDef` and `DefId`. You can get the `AdtDef` for a
+`DefId` with the [`tcx.adt_def(def_id)` query][adtdefq]. `AdtDef`s are all interned, as shown
+by the `'tcx` lifetime.
+
+[adtdefq]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.adt_def
+
+
+## Type errors
+
+There is a `TyKind::Error` that is produced when the user makes a type error. The idea is that
+we would propagate this type and suppress other errors that come up due to it so as not to overwhelm
+the user with cascading compiler error messages.
+
+There is an **important invariant** for `TyKind::Error`. The compiler should
+**never** produce `Error` unless we **know** that an error has already been
+reported to the user. This is usually
+because (a) you just reported it right there or (b) you are propagating an existing Error type (in
+which case the error should've been reported when that error type was produced).
+
+It's important to maintain this invariant because the whole point of the `Error` type is to suppress
+other errors -- i.e., we don't report them. If we were to produce an `Error` type without actually
+emitting an error to the user, then this could cause later errors to be suppressed, and the
+compilation might inadvertently succeed!
+
+Sometimes there is a third case. You believe that an error has been reported, but you believe it
+would've been reported earlier in the compilation, not locally. In that case, you can invoke
+[`delay_span_bug`] This will make a note that you expect compilation to yield an error -- if however
+compilation should succeed, then it will trigger a compiler bug report.
+
+[`delay_span_bug`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/struct.Session.html#method.delay_span_bug
+
+For added safety, it's not actually possible to produce a `TyKind::Error` value
+outside of [`rustc_middle::ty`][ty]; there is a private member of
+`TyKind::Error` that prevents it from being constructable elsewhere. Instead,
+one should use the [`TyCtxt::ty_error`][terr] or
+[`TyCtxt::ty_error_with_message`][terrmsg] methods. These methods automatically
+call `delay_span_bug` before returning an interned `Ty` of kind `Error`. If you
+were already planning to use [`delay_span_bug`], then you can just pass the
+span and message to [`ty_error_with_message`][terrmsg] instead to avoid
+delaying a redundant span bug.
+
+[terr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.ty_error
+[terrmsg]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.ty_error_with_message
+
+## Question: Why not substitute “inside” the `AdtDef`?
+
+Recall that we represent a generic struct with `(AdtDef, substs)`. So why bother with this scheme?
+
+Well, the alternate way we could have chosen to represent types would be to always create a new,
+fully-substituted form of the `AdtDef` where all the types are already substituted. This seems like
+less of a hassle. However, the `(AdtDef, substs)` scheme has some advantages over this.
+
+First, `(AdtDef, substs)` scheme has an efficiency win:
+
+```rust,ignore
+struct MyStruct<T> {
+  ... 100s of fields ...
+}
+
+// Want to do: MyStruct<A> ==> MyStruct<B>
+```
+
+in an example like this, we can subst from `MyStruct<A>` to `MyStruct<B>` (and so on) very cheaply,
+by just replacing the one reference to `A` with `B`. But if we eagerly substituted all the fields,
+that could be a lot more work because we might have to go through all of the fields in the `AdtDef`
+and update all of their types.
+
+A bit more deeply, this corresponds to structs in Rust being [*nominal* types][nominal] — which
+means that they are defined by their *name* (and that their contents are then indexed from the
+definition of that name, and not carried along “within” the type itself).
+
+[nominal]: https://en.wikipedia.org/wiki/Nominal_type_system
diff --git a/src/doc/rustc-dev-guide/src/type-checking.md b/src/doc/rustc-dev-guide/src/type-checking.md
new file mode 100644
index 000000000..cd58faf22
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/type-checking.md
@@ -0,0 +1,44 @@
+# Type checking
+
+The [`rustc_typeck`][typeck] crate contains the source for "type collection"
+and "type checking", as well as a few other bits of related functionality. (It
+draws heavily on the [type inference] and [trait solving].)
+
+[typeck]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/index.html
+[type inference]: ./type-inference.md
+[trait solving]: ./traits/resolution.md
+
+## Type collection
+
+Type "collection" is the process of converting the types found in the HIR
+(`hir::Ty`), which represent the syntactic things that the user wrote, into the
+**internal representation** used by the compiler (`Ty<'tcx>`) – we also do
+similar conversions for where-clauses and other bits of the function signature.
+
+To try and get a sense for the difference, consider this function:
+
+```rust,ignore
+struct Foo { }
+fn foo(x: Foo, y: self::Foo) { ... }
+//        ^^^     ^^^^^^^^^
+```
+
+Those two parameters `x` and `y` each have the same type: but they will have
+distinct `hir::Ty` nodes. Those nodes will have different spans, and of course
+they encode the path somewhat differently. But once they are "collected" into
+`Ty<'tcx>` nodes, they will be represented by the exact same internal type.
+
+Collection is defined as a bundle of [queries] for computing information about
+the various functions, traits, and other items in the crate being compiled.
+Note that each of these queries is concerned with *interprocedural* things –
+for example, for a function definition, collection will figure out the type and
+signature of the function, but it will not visit the *body* of the function in
+any way, nor examine type annotations on local variables (that's the job of
+type *checking*).
+
+For more details, see the [`collect`][collect] module.
+
+[queries]: ./query.md
+[collect]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_typeck/collect/
+
+**TODO**: actually talk about type checking... [#1161](https://github.com/rust-lang/rustc-dev-guide/issues/1161)
diff --git a/src/doc/rustc-dev-guide/src/type-inference.md b/src/doc/rustc-dev-guide/src/type-inference.md
new file mode 100644
index 000000000..4be9211ee
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/type-inference.md
@@ -0,0 +1,258 @@
+# Type inference
+
+<!-- toc -->
+
+Type inference is the process of automatic detection of the type of an
+expression.
+
+It is what allows Rust to work with fewer or no type annotations,
+making things easier for users:
+
+```rust
+fn main() {
+    let mut things = vec![];
+    things.push("thing");
+}
+```
+
+Here, the type of `things` is *inferred* to be `Vec<&str>` because of the value
+we push into `things`.
+
+The type inference is based on the standard Hindley-Milner (HM) type inference
+algorithm, but extended in various way to accommodate subtyping, region
+inference, and higher-ranked types.
+
+## A note on terminology
+
+We use the notation `?T` to refer to inference variables, also called
+existential variables.
+
+We use the terms "region" and "lifetime" interchangeably. Both refer to
+the `'a` in `&'a T`.
+
+The term "bound region" refers to a region that is bound in a function
+signature, such as the `'a` in `for<'a> fn(&'a u32)`. A region is
+"free" if it is not bound.
+
+## Creating an inference context
+
+You create and "enter" an inference context by doing something like
+the following:
+
+```rust,ignore
+tcx.infer_ctxt().enter(|infcx| {
+    // Use the inference context `infcx` here.
+})
+```
+
+Within the closure, `infcx` has the type `InferCtxt<'cx, 'tcx>` for some
+fresh `'cx`, while `'tcx` is the same as outside the inference context.
+(Again, see the [`ty` chapter][ty-ch] for more details on this setup.)
+
+[ty-ch]: ty.html
+
+The `tcx.infer_ctxt` method actually returns a builder, which means
+there are some kinds of configuration you can do before the `infcx` is
+created. See `InferCtxtBuilder` for more information.
+
+<a name="vars"></a>
+
+## Inference variables
+
+The main purpose of the inference context is to house a bunch of
+**inference variables** – these represent types or regions whose precise
+value is not yet known, but will be uncovered as we perform type-checking.
+
+If you're familiar with the basic ideas of unification from H-M type
+systems, or logic languages like Prolog, this is the same concept. If
+you're not, you might want to read a tutorial on how H-M type
+inference works, or perhaps this blog post on
+[unification in the Chalk project].
+
+[Unification in the Chalk project]: http://smallcultfollowing.com/babysteps/blog/2017/03/25/unification-in-chalk-part-1/
+
+All told, the inference context stores five kinds of inference variables
+(as of <!-- date: 2021-06 --> June 2021):
+
+- Type variables, which come in three varieties:
+  - General type variables (the most common). These can be unified with any
+    type.
+  - Integral type variables, which can only be unified with an integral type,
+    and arise from an integer literal expression like `22`.
+  - Float type variables, which can only be unified with a float type, and
+    arise from a float literal expression like `22.0`.
+- Region variables, which represent lifetimes, and arise all over the place.
+- Const variables, which represent constants.
+
+All the type variables work in much the same way: you can create a new
+type variable, and what you get is `Ty<'tcx>` representing an
+unresolved type `?T`. Then later you can apply the various operations
+that the inferencer supports, such as equality or subtyping, and it
+will possibly **instantiate** (or **bind**) that `?T` to a specific
+value as a result.
+
+The region variables work somewhat differently, and are described
+below in a separate section.
+
+## Enforcing equality / subtyping
+
+The most basic operations you can perform in the type inferencer is
+**equality**, which forces two types `T` and `U` to be the same. The
+recommended way to add an equality constraint is to use the `at`
+method, roughly like so:
+
+```rust,ignore
+infcx.at(...).eq(t, u);
+```
+
+The first `at()` call provides a bit of context, i.e. why you are
+doing this unification, and in what environment, and the `eq` method
+performs the actual equality constraint.
+
+When you equate things, you force them to be precisely equal. Equating
+returns an `InferResult` – if it returns `Err(err)`, then equating
+failed, and the enclosing `TypeError` will tell you what went wrong.
+
+The success case is perhaps more interesting. The "primary" return
+type of `eq` is `()` – that is, when it succeeds, it doesn't return a
+value of any particular interest. Rather, it is executed for its
+side-effects of constraining type variables and so forth. However, the
+actual return type is not `()`, but rather `InferOk<()>`. The
+`InferOk` type is used to carry extra trait obligations – your job is
+to ensure that these are fulfilled (typically by enrolling them in a
+fulfillment context). See the [trait chapter] for more background on that.
+
+[trait chapter]: traits/resolution.html
+
+You can similarly enforce subtyping through `infcx.at(..).sub(..)`. The same
+basic concepts as above apply.
+
+## "Trying" equality
+
+Sometimes you would like to know if it is *possible* to equate two
+types without error.  You can test that with `infcx.can_eq` (or
+`infcx.can_sub` for subtyping). If this returns `Ok`, then equality
+is possible – but in all cases, any side-effects are reversed.
+
+Be aware, though, that the success or failure of these methods is always
+**modulo regions**. That is, two types `&'a u32` and `&'b u32` will
+return `Ok` for `can_eq`, even if `'a != 'b`.  This falls out from the
+"two-phase" nature of how we solve region constraints.
+
+## Snapshots
+
+As described in the previous section on `can_eq`, often it is useful
+to be able to do a series of operations and then roll back their
+side-effects. This is done for various reasons: one of them is to be
+able to backtrack, trying out multiple possibilities before settling
+on which path to take. Another is in order to ensure that a series of
+smaller changes take place atomically or not at all.
+
+To allow for this, the inference context supports a `snapshot` method.
+When you call it, it will start recording changes that occur from the
+operations you perform. When you are done, you can either invoke
+`rollback_to`, which will undo those changes, or else `confirm`, which
+will make them permanent. Snapshots can be nested as long as you follow
+a stack-like discipline.
+
+Rather than use snapshots directly, it is often helpful to use the
+methods like `commit_if_ok` or `probe` that encapsulate higher-level
+patterns.
+
+## Subtyping obligations
+
+One thing worth discussing is subtyping obligations. When you force
+two types to be a subtype, like `?T <: i32`, we can often convert those
+into equality constraints. This follows from Rust's rather limited notion
+of subtyping: so, in the above case, `?T <: i32` is equivalent to `?T = i32`.
+
+However, in some cases we have to be more careful. For example, when
+regions are involved. So if you have `?T <: &'a i32`, what we would do
+is to first "generalize" `&'a i32` into a type with a region variable:
+`&'?b i32`, and then unify `?T` with that (`?T = &'?b i32`). We then
+relate this new variable with the original bound:
+
+```text
+&'?b i32 <: &'a i32
+```
+
+This will result in a region constraint (see below) of `'?b: 'a`.
+
+One final interesting case is relating two unbound type variables,
+like `?T <: ?U`.  In that case, we can't make progress, so we enqueue
+an obligation `Subtype(?T, ?U)` and return it via the `InferOk`
+mechanism. You'll have to try again when more details about `?T` or
+`?U` are known.
+
+## Region constraints
+
+Regions are inferenced somewhat differently from types. Rather than
+eagerly unifying things, we simply collect constraints as we go, but
+make (almost) no attempt to solve regions. These constraints have the
+form of an "outlives" constraint:
+
+```text
+'a: 'b
+```
+
+Actually the code tends to view them as a subregion relation, but it's the same
+idea:
+
+```text
+'b <= 'a
+```
+
+(There are various other kinds of constraints, such as "verifys"; see
+the [`region_constraints`] module for details.)
+
+There is one case where we do some amount of eager unification. If you have an
+equality constraint between two regions
+
+```text
+'a = 'b
+```
+
+we will record that fact in a unification table. You can then use
+[`opportunistic_resolve_var`] to convert `'b` to `'a` (or vice
+versa). This is sometimes needed to ensure termination of fixed-point
+algorithms.
+
+[`region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/region_constraints/index.html
+[`opportunistic_resolve_var`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/region_constraints/struct.RegionConstraintCollector.html#method.opportunistic_resolve_var
+
+## Extracting region constraints
+
+Ultimately, region constraints are only solved at the very end of
+type-checking, once all other constraints are known. There are two
+ways to solve region constraints right now: lexical and
+non-lexical. Eventually there will only be one.
+
+To solve **lexical** region constraints, you invoke
+[`resolve_regions_and_report_errors`].  This "closes" the region
+constraint process and invokes the [`lexical_region_resolve`] code. Once
+this is done, any further attempt to equate or create a subtyping
+relationship will yield an ICE.
+
+Non-lexical region constraints are not handled within the inference
+context. Instead, the NLL solver (actually, the MIR type-checker)
+invokes [`take_and_reset_region_constraints`] periodically. This
+extracts all of the outlives constraints from the region solver, but
+leaves the set of variables intact. This is used to get *just* the
+region constraints that resulted from some particular point in the
+program, since the NLL solver needs to know not just *what* regions
+were subregions, but also *where*. Finally, the NLL solver invokes
+[`take_region_var_origins`], which "closes" the region constraint
+process in the same way as normal solving.
+
+[`resolve_regions_and_report_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.resolve_regions_and_report_errors
+[`lexical_region_resolve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/lexical_region_resolve/index.html
+[`take_and_reset_region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_and_reset_region_constraints
+[`take_region_var_origins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_region_var_origins
+
+## Lexical region resolution
+
+Lexical region resolution is done by initially assigning each region
+variable to an empty value. We then process each outlives constraint
+repeatedly, growing region variables until a fixed-point is reached.
+Region variables can be grown using a least-upper-bound relation on
+the region lattice in a fairly straightforward fashion.
diff --git a/src/doc/rustc-dev-guide/src/variance.md b/src/doc/rustc-dev-guide/src/variance.md
new file mode 100644
index 000000000..c03de7a20
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/variance.md
@@ -0,0 +1,318 @@
+# Variance of type and lifetime parameters
+
+<!-- toc -->
+
+For a more general background on variance, see the [background] appendix.
+
+[background]: ./appendix/background.html
+
+During type checking we must infer the variance of type and lifetime
+parameters. The algorithm is taken from Section 4 of the paper ["Taming the
+Wildcards: Combining Definition- and Use-Site Variance"][pldi11] published in
+PLDI'11 and written by Altidor et al., and hereafter referred to as The Paper.
+
+[pldi11]: https://people.cs.umass.edu/~yannis/variance-extended2011.pdf
+
+This inference is explicitly designed *not* to consider the uses of
+types within code. To determine the variance of type parameters
+defined on type `X`, we only consider the definition of the type `X`
+and the definitions of any types it references.
+
+We only infer variance for type parameters found on *data types*
+like structs and enums. In these cases, there is a fairly straightforward
+explanation for what variance means. The variance of the type
+or lifetime parameters defines whether `T<A>` is a subtype of `T<B>`
+(resp. `T<'a>` and `T<'b>`) based on the relationship of `A` and `B`
+(resp. `'a` and `'b`).
+
+We do not infer variance for type parameters found on traits, functions,
+or impls. Variance on trait parameters can indeed make sense
+(and we used to compute it) but it is actually rather subtle in
+meaning and not that useful in practice, so we removed it. See the
+[addendum] for some details. Variances on function/impl parameters, on the
+other hand, doesn't make sense because these parameters are instantiated and
+then forgotten, they don't persist in types or compiled byproducts.
+
+[addendum]: #addendum
+
+> **Notation**
+>
+> We use the notation of The Paper throughout this chapter:
+>
+> - `+` is _covariance_.
+> - `-` is _contravariance_.
+> - `*` is _bivariance_.
+> - `o` is _invariance_.
+
+## The algorithm
+
+The basic idea is quite straightforward. We iterate over the types
+defined and, for each use of a type parameter `X`, accumulate a
+constraint indicating that the variance of `X` must be valid for the
+variance of that use site. We then iteratively refine the variance of
+`X` until all constraints are met. There is *always* a solution, because at
+the limit we can declare all type parameters to be invariant and all
+constraints will be satisfied.
+
+As a simple example, consider:
+
+```rust,ignore
+enum Option<A> { Some(A), None }
+enum OptionalFn<B> { Some(|B|), None }
+enum OptionalMap<C> { Some(|C| -> C), None }
+```
+
+Here, we will generate the constraints:
+
+```text
+1. V(A) <= +
+2. V(B) <= -
+3. V(C) <= +
+4. V(C) <= -
+```
+
+These indicate that (1) the variance of A must be at most covariant;
+(2) the variance of B must be at most contravariant; and (3, 4) the
+variance of C must be at most covariant *and* contravariant. All of these
+results are based on a variance lattice defined as follows:
+
+```text
+   *      Top (bivariant)
+-     +
+   o      Bottom (invariant)
+```
+
+Based on this lattice, the solution `V(A)=+`, `V(B)=-`, `V(C)=o` is the
+optimal solution. Note that there is always a naive solution which
+just declares all variables to be invariant.
+
+You may be wondering why fixed-point iteration is required. The reason
+is that the variance of a use site may itself be a function of the
+variance of other type parameters. In full generality, our constraints
+take the form:
+
+```text
+V(X) <= Term
+Term := + | - | * | o | V(X) | Term x Term
+```
+
+Here the notation `V(X)` indicates the variance of a type/region
+parameter `X` with respect to its defining class. `Term x Term`
+represents the "variance transform" as defined in the paper:
+
+>  If the variance of a type variable `X` in type expression `E` is `V2`
+  and the definition-site variance of the corresponding type parameter
+  of a class `C` is `V1`, then the variance of `X` in the type expression
+  `C<E>` is `V3 = V1.xform(V2)`.
+
+## Constraints
+
+If I have a struct or enum with where clauses:
+
+```rust,ignore
+struct Foo<T: Bar> { ... }
+```
+
+you might wonder whether the variance of `T` with respect to `Bar` affects the
+variance `T` with respect to `Foo`. I claim no.  The reason: assume that `T` is
+invariant with respect to `Bar` but covariant with respect to `Foo`. And then
+we have a `Foo<X>` that is upcast to `Foo<Y>`, where `X <: Y`. However, while
+`X : Bar`, `Y : Bar` does not hold.  In that case, the upcast will be illegal,
+but not because of a variance failure, but rather because the target type
+`Foo<Y>` is itself just not well-formed. Basically we get to assume
+well-formedness of all types involved before considering variance.
+
+### Dependency graph management
+
+Because variance is a whole-crate inference, its dependency graph
+can become quite muddled if we are not careful. To resolve this, we refactor
+into two queries:
+
+- `crate_variances` computes the variance for all items in the current crate.
+- `variances_of` accesses the variance for an individual reading; it
+  works by requesting `crate_variances` and extracting the relevant data.
+
+If you limit yourself to reading `variances_of`, your code will only
+depend then on the inference of that particular item.
+
+Ultimately, this setup relies on the [red-green algorithm][rga]. In particular,
+every variance query effectively depends on all type definitions in the entire
+crate (through `crate_variances`), but since most changes will not result in a
+change to the actual results from variance inference, the `variances_of` query
+will wind up being considered green after it is re-evaluated.
+
+[rga]: ./queries/incremental-compilation.html
+
+<a name="addendum"></a>
+
+## Addendum: Variance on traits
+
+As mentioned above, we used to permit variance on traits. This was
+computed based on the appearance of trait type parameters in
+method signatures and was used to represent the compatibility of
+vtables in trait objects (and also "virtual" vtables or dictionary
+in trait bounds). One complication was that variance for
+associated types is less obvious, since they can be projected out
+and put to myriad uses, so it's not clear when it is safe to allow
+`X<A>::Bar` to vary (or indeed just what that means). Moreover (as
+covered below) all inputs on any trait with an associated type had
+to be invariant, limiting the applicability. Finally, the
+annotations (`MarkerTrait`, `PhantomFn`) needed to ensure that all
+trait type parameters had a variance were confusing and annoying
+for little benefit.
+
+Just for historical reference, I am going to preserve some text indicating how
+one could interpret variance and trait matching.
+
+### Variance and object types
+
+Just as with structs and enums, we can decide the subtyping
+relationship between two object types `&Trait<A>` and `&Trait<B>`
+based on the relationship of `A` and `B`. Note that for object
+types we ignore the `Self` type parameter – it is unknown, and
+the nature of dynamic dispatch ensures that we will always call a
+function that is expected the appropriate `Self` type. However, we
+must be careful with the other type parameters, or else we could
+end up calling a function that is expecting one type but provided
+another.
+
+To see what I mean, consider a trait like so:
+
+```rust
+trait ConvertTo<A> {
+    fn convertTo(&self) -> A;
+}
+```
+
+Intuitively, If we had one object `O=&ConvertTo<Object>` and another
+`S=&ConvertTo<String>`, then `S <: O` because `String <: Object`
+(presuming Java-like "string" and "object" types, my go to examples
+for subtyping). The actual algorithm would be to compare the
+(explicit) type parameters pairwise respecting their variance: here,
+the type parameter A is covariant (it appears only in a return
+position), and hence we require that `String <: Object`.
+
+You'll note though that we did not consider the binding for the
+(implicit) `Self` type parameter: in fact, it is unknown, so that's
+good. The reason we can ignore that parameter is precisely because we
+don't need to know its value until a call occurs, and at that time (as
+you said) the dynamic nature of virtual dispatch means the code we run
+will be correct for whatever value `Self` happens to be bound to for
+the particular object whose method we called. `Self` is thus different
+from `A`, because the caller requires that `A` be known in order to
+know the return type of the method `convertTo()`. (As an aside, we
+have rules preventing methods where `Self` appears outside of the
+receiver position from being called via an object.)
+
+### Trait variance and vtable resolution
+
+But traits aren't only used with objects. They're also used when
+deciding whether a given impl satisfies a given trait bound. To set the
+scene here, imagine I had a function:
+
+```rust,ignore
+fn convertAll<A,T:ConvertTo<A>>(v: &[T]) { ... }
+```
+
+Now imagine that I have an implementation of `ConvertTo` for `Object`:
+
+```rust,ignore
+impl ConvertTo<i32> for Object { ... }
+```
+
+And I want to call `convertAll` on an array of strings. Suppose
+further that for whatever reason I specifically supply the value of
+`String` for the type parameter `T`:
+
+```rust,ignore
+let mut vector = vec!["string", ...];
+convertAll::<i32, String>(vector);
+```
+
+Is this legal? To put another way, can we apply the `impl` for
+`Object` to the type `String`? The answer is yes, but to see why
+we have to expand out what will happen:
+
+- `convertAll` will create a pointer to one of the entries in the
+  vector, which will have type `&String`
+- It will then call the impl of `convertTo()` that is intended
+  for use with objects. This has the type `fn(self: &Object) -> i32`.
+
+  It is OK to provide a value for `self` of type `&String` because
+  `&String <: &Object`.
+
+OK, so intuitively we want this to be legal, so let's bring this back
+to variance and see whether we are computing the correct result. We
+must first figure out how to phrase the question "is an impl for
+`Object,i32` usable where an impl for `String,i32` is expected?"
+
+Maybe it's helpful to think of a dictionary-passing implementation of
+type classes. In that case, `convertAll()` takes an implicit parameter
+representing the impl. In short, we *have* an impl of type:
+
+```text
+V_O = ConvertTo<i32> for Object
+```
+
+and the function prototype expects an impl of type:
+
+```text
+V_S = ConvertTo<i32> for String
+```
+
+As with any argument, this is legal if the type of the value given
+(`V_O`) is a subtype of the type expected (`V_S`). So is `V_O <: V_S`?
+The answer will depend on the variance of the various parameters. In
+this case, because the `Self` parameter is contravariant and `A` is
+covariant, it means that:
+
+```text
+V_O <: V_S iff
+    i32 <: i32
+    String <: Object
+```
+
+These conditions are satisfied and so we are happy.
+
+### Variance and associated types
+
+Traits with associated types – or at minimum projection
+expressions – must be invariant with respect to all of their
+inputs. To see why this makes sense, consider what subtyping for a
+trait reference means:
+
+```text
+<T as Trait> <: <U as Trait>
+```
+
+means that if I know that `T as Trait`, I also know that `U as
+Trait`. Moreover, if you think of it as dictionary passing style,
+it means that a dictionary for `<T as Trait>` is safe to use where
+a dictionary for `<U as Trait>` is expected.
+
+The problem is that when you can project types out from `<T as
+Trait>`, the relationship to types projected out of `<U as Trait>`
+is completely unknown unless `T==U` (see #21726 for more
+details). Making `Trait` invariant ensures that this is true.
+
+Another related reason is that if we didn't make traits with
+associated types invariant, then projection is no longer a
+function with a single result. Consider:
+
+```rust,ignore
+trait Identity { type Out; fn foo(&self); }
+impl<T> Identity for T { type Out = T; ... }
+```
+
+Now if I have `<&'static () as Identity>::Out`, this can be
+validly derived as `&'a ()` for any `'a`:
+
+```text
+<&'a () as Identity> <: <&'static () as Identity>
+if &'static () < : &'a ()   -- Identity is contravariant in Self
+if 'static : 'a             -- Subtyping rules for relations
+```
+
+This change otoh means that `<'static () as Identity>::Out` is
+always `&'static ()` (which might then be upcast to `'a ()`,
+separately). This was helpful in solving #21750.
diff --git a/src/doc/rustc-dev-guide/src/walkthrough.md b/src/doc/rustc-dev-guide/src/walkthrough.md
new file mode 100644
index 000000000..84cb1296f
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/walkthrough.md
@@ -0,0 +1,267 @@
+# Walkthrough: a typical contribution
+
+<!-- toc -->
+
+There are _a lot_ of ways to contribute to the Rust compiler, including fixing
+bugs, improving performance, helping design features, providing feedback on
+existing features, etc. This chapter does not claim to scratch the surface.
+Instead, it walks through the design and implementation of a new feature. Not
+all of the steps and processes described here are needed for every
+contribution, and I will try to point those out as they arise.
+
+In general, if you are interested in making a contribution and aren't sure
+where to start, please feel free to ask!
+
+## Overview
+
+The feature I will discuss in this chapter is the `?` Kleene operator for
+macros. Basically, we want to be able to write something like this:
+
+```rust,ignore
+macro_rules! foo {
+    ($arg:ident $(, $optional_arg:ident)?) => {
+        println!("{}", $arg);
+
+        $(
+            println!("{}", $optional_arg);
+        )?
+    }
+}
+
+fn main() {
+    let x = 0;
+    foo!(x); // ok! prints "0"
+    foo!(x, x); // ok! prints "0 0"
+}
+```
+
+So basically, the `$(pat)?` matcher in the macro means "this pattern can occur
+0 or 1 times", similar to other regex syntaxes.
+
+There were a number of steps to go from an idea to stable Rust feature. Here is
+a quick list.  We will go through each of these in order below. As I mentioned
+before, not all of these are needed for every type of contribution.
+
+- **Idea discussion/Pre-RFC**  A Pre-RFC is an early draft or design discussion
+  of a feature. This stage is intended to flesh out the design space a bit and
+  get a grasp on the different merits and problems with an idea. It's a great
+  way to get early feedback on your idea before presenting it the wider
+  audience. You can find the original discussion [here][prerfc].
+- **RFC**  This is when you formally present your idea to the community for
+  consideration. You can find the RFC [here][rfc].
+- **Implementation** Implement your idea unstably in the compiler. You can
+  find the original implementation [here][impl1].
+- **Possibly iterate/refine** As the community gets experience with your
+  feature on the nightly compiler and in `std`, there may be additional
+  feedback about design choice that might be adjusted. This particular feature
+  went [through][impl2] a [number][impl3] of [iterations][impl4].
+- **Stabilization** When your feature has baked enough, a Rust team member may
+  [propose to stabilize it][merge]. If there is consensus, this is done.
+- **Relax** Your feature is now a stable Rust feature!
+
+[prerfc]: https://internals.rust-lang.org/t/pre-rfc-at-most-one-repetition-macro-patterns/6557
+[rfc]: https://github.com/rust-lang/rfcs/pull/2298
+[impl1]: https://github.com/rust-lang/rust/pull/47752
+[impl2]: https://github.com/rust-lang/rust/pull/49719
+[impl3]: https://github.com/rust-lang/rust/pull/51336
+[impl4]: https://github.com/rust-lang/rust/pull/51587
+[merge]: https://github.com/rust-lang/rust/issues/48075#issuecomment-433177613
+
+## Pre-RFC and RFC
+
+> NOTE: In general, if you are not proposing a _new_ feature or substantial
+> change to Rust or the ecosystem, you don't need to follow the RFC process.
+> Instead, you can just jump to [implementation](#impl).
+>
+> You can find the official guidelines for when to open an RFC [here][rfcwhen].
+
+[rfcwhen]: https://github.com/rust-lang/rfcs#when-you-need-to-follow-this-process
+
+An RFC is a document that describes the feature or change you are proposing in
+detail. Anyone can write an RFC; the process is the same for everyone,
+including Rust team members.
+
+To open an RFC, open a PR on the
+[rust-lang/rfcs](https://github.com/rust-lang/rfcs) repo on GitHub. You can
+find detailed instructions in the
+[README](https://github.com/rust-lang/rfcs#what-the-process-is).
+
+Before opening an RFC, you should do the research to "flesh out" your idea.
+Hastily-proposed RFCs tend not to be accepted. You should generally have a good
+description of the motivation, impact, disadvantages, and potential
+interactions with other features.
+
+If that sounds like a lot of work, it's because it is. But no fear! Even if
+you're not a compiler hacker, you can get great feedback by doing a _pre-RFC_.
+This is an _informal_ discussion of the idea. The best place to do this is
+internals.rust-lang.org. Your post doesn't have to follow any particular
+structure.  It doesn't even need to be a cohesive idea. Generally, you will get
+tons of feedback that you can integrate back to produce a good RFC.
+
+(Another pro-tip: try searching the RFCs repo and internals for prior related
+ideas. A lot of times an idea has already been considered and was either
+rejected or postponed to be tried again later. This can save you and everybody
+else some time)
+
+In the case of our example, a participant in the pre-RFC thread pointed out a
+syntax ambiguity and a potential resolution. Also, the overall feedback seemed
+positive. In this case, the discussion converged pretty quickly, but for some
+ideas, a lot more discussion can happen (e.g. see [this RFC][nonascii] which
+received a whopping 684 comments!). If that happens, don't be discouraged; it
+means the community is interested in your idea, but it perhaps needs some
+adjustments.
+
+[nonascii]: https://github.com/rust-lang/rfcs/pull/2457
+
+The RFC for our `?` macro feature did receive some discussion on the RFC thread
+too.  As with most RFCs, there were a few questions that we couldn't answer by
+discussion: we needed experience using the feature to decide. Such questions
+are listed in the "Unresolved Questions" section of the RFC. Also, over the
+course of the RFC discussion, you will probably want to update the RFC document
+itself to reflect the course of the discussion (e.g. new alternatives or prior
+work may be added or you may decide to change parts of the proposal itself).
+
+In the end, when the discussion seems to reach a consensus and die down a bit,
+a Rust team member may propose to move to "final comment period" (FCP) with one
+of three possible dispositions. This means that they want the other members of
+the appropriate teams to review and comment on the RFC. More discussion may
+ensue, which may result in more changes or unresolved questions being added. At
+some point, when everyone is satisfied, the RFC enters the FCP, which is the
+last chance for people to bring up objections. When the FCP is over, the
+disposition is adopted. Here are the three possible dispositions:
+
+- _Merge_: accept the feature. Here is the proposal to merge for our [`?` macro
+  feature][rfcmerge].
+- _Close_: this feature in its current form is not a good fit for rust. Don't
+  be discouraged if this happens to your RFC, and don't take it personally.
+  This is not a reflection on you, but rather a community decision that rust
+  will go a different direction.
+- _Postpone_: there is interest in going this direction but not at the moment.
+  This happens most often because the appropriate Rust team doesn't have the
+  bandwidth to shepherd the feature through the process to stabilization. Often
+  this is the case when the feature doesn't fit into the team's roadmap.
+  Postponed ideas may be revisited later.
+
+[rfcmerge]: https://github.com/rust-lang/rfcs/pull/2298#issuecomment-360582667
+
+When an RFC is merged, the PR is merged into the RFCs repo. A new _tracking
+issue_ is created in the [rust-lang/rust] repo to track progress on the feature
+and discuss unresolved questions, implementation progress and blockers, etc.
+Here is the tracking issue on for our [`?` macro feature][tracking].
+
+[tracking]: https://github.com/rust-lang/rust/issues/48075
+
+<a name="impl"></a>
+
+## Implementation
+
+To make a change to the compiler, open a PR against the [rust-lang/rust] repo.
+
+[rust-lang/rust]: https://github.com/rust-lang/rust
+
+Depending on the feature/change/bug fix/improvement, implementation may be
+relatively-straightforward or it may be a major undertaking. You can always ask
+for help or mentorship from more experienced compiler devs.  Also, you don't
+have to be the one to implement your feature; but keep in mind that if you
+don't it might be a while before someone else does.
+
+For the `?` macro feature, I needed to go understand the relevant parts of
+macro expansion in the compiler. Personally, I find that [improving the
+comments][comments] in the code is a helpful way of making sure I understand
+it, but you don't have to do that if you don't want to.
+
+[comments]: https://github.com/rust-lang/rust/pull/47732
+
+I then [implemented][impl1] the original feature, as described in the RFC. When
+a new feature is implemented, it goes behind a _feature gate_, which means that
+you have to use `#![feature(my_feature_name)]` to use the feature. The feature
+gate is removed when the feature is stabilized.
+
+**Most bug fixes and improvements** don't require a feature gate. You can just
+make your changes/improvements.
+
+When you open a PR on the [rust-lang/rust], a bot will assign your PR to a
+review. If there is a particular Rust team member you are working with, you can
+request that reviewer by leaving a comment on the thread with `r?
+@reviewer-github-id` (e.g. `r? @eddyb`). If you don't know who to request,
+don't request anyone; the bot will assign someone automatically based on which files you changed.
+
+The reviewer may request changes before they approve your PR. Feel free to ask
+questions or discuss things you don't understand or disagree with. However,
+recognize that the PR won't be merged unless someone on the Rust team approves
+it.
+
+When your reviewer approves the PR, it will go into a queue for yet another bot
+called `@bors`. `@bors` manages the CI build/merge queue. When your PR reaches
+the head of the `@bors` queue, `@bors` will test out the merge by running all
+tests against your PR on GitHub Actions. This takes a lot of time to
+finish. If all tests pass, the PR is merged and becomes part of the next
+nightly compiler!
+
+There are a couple of things that may happen for some PRs during the review process
+
+- If the change is substantial enough, the reviewer may request an FCP on
+  the PR. This gives all members of the appropriate team a chance to review the
+  changes.
+- If the change may cause breakage, the reviewer may request a [crater] run.
+  This compiles the compiler with your changes and then attempts to compile all
+  crates on crates.io with your modified compiler. This is a great smoke test
+  to check if you introduced a change to compiler behavior that affects a large
+  portion of the ecosystem.
+- If the diff of your PR is large or the reviewer is busy, your PR may have
+  some merge conflicts with other PRs that happen to get merged first. You
+  should fix these merge conflicts using the normal git procedures.
+
+[crater]: ./tests/intro.html#crater
+
+If you are not doing a new feature or something like that (e.g. if you are
+fixing a bug), then that's it! Thanks for your contribution :)
+
+## Refining your implementation
+
+As people get experience with your new feature on nightly, slight changes may
+be proposed and unresolved questions may become resolved. Updates/changes go
+through the same process for implementing any other changes, as described
+above (i.e. submit a PR, go through review, wait for `@bors`, etc).
+
+Some changes may be major enough to require an FCP and some review by Rust team
+members.
+
+For the `?` macro feature, we went through a few different iterations after the
+original implementation: [1][impl2], [2][impl3], [3][impl4].
+
+Along the way, we decided that `?` should not take a separator, which was
+previously an unresolved question listed in the RFC. We also changed the
+disambiguation strategy: we decided to remove the ability to use `?` as a
+separator token for other repetition operators (e.g. `+` or `*`). However,
+since this was a breaking change, we decided to do it over an edition boundary.
+Thus, the new feature can be enabled only in edition 2018. These deviations
+from the original RFC required [another
+FCP](https://github.com/rust-lang/rust/issues/51934).
+
+## Stabilization
+
+Finally, after the feature had baked for a while on nightly, a language team member
+[moved to stabilize it][stabilizefcp].
+
+[stabilizefcp]: https://github.com/rust-lang/rust/issues/48075#issuecomment-433177613
+
+A _stabilization report_ needs to be written that includes
+
+- brief description of the behavior and any deviations from the RFC
+- which edition(s) are affected and how
+- links to a few tests to show the interesting aspects
+
+The stabilization report for our feature is [here][stabrep].
+
+[stabrep]: https://github.com/rust-lang/rust/issues/48075#issuecomment-433243048
+
+After this, [a PR is made][stab] to remove the feature gate, enabling the feature by
+default (on the 2018 edition). A note is added to the [Release notes][relnotes]
+about the feature.
+
+[stab]: https://github.com/rust-lang/rust/pull/56245
+
+Steps to stabilize the feature can be found at [Stabilizing Features](./stabilization_guide.md).
+
+[relnotes]: https://github.com/rust-lang/rust/blob/master/RELEASES.md